2025 年 7月我在上交的时候还自豪的称自己是“古法”编程师，然而时至今日不得不承认的是AI Agent (下文简称 AI) 发展确实日新月异，尤其是以 GPT-5 为代表的新一代长Context 高 Reasoning 强 Agentic 的模型发布以来，AI在写代码这块的进步有目共睹。本文想从一名“古法”编程师的角度来探讨：

• AI 在编码这块已经可以做什么？
• 剩下的事情 AI 为什么还做不到？
• “古法”还有前途吗？AI 未来是什么？

本文纯“古法”打造

“古法” 的困境

写代码长期以来很多人觉得基本属于是脑力劳动，但实质上很多资深程序员和我有一样的感悟：当编码能力到一定地步后，大部分写代码其实都成了重复性的体力劳动。

举一个例子，假设我现在想实现一个类似 Clang/GCC 的编译器，至少符合 C89标准，并且尽量不使用现有的编译器基建设施，我的计划大抵会是[1]：

• 阅读 C89 标准设计，设计前端
• 选择一种合适的 Parser，比如 LL/LALR/递归下降，想好 AST/IR之类的大概设计
• 先尝试支持语法子集，用足够的测试样例确保 Parser 设计的合理性
• 进入循环：支持更多 Feature，添加样例，同时确保没有regression，有必要的话回头改之前的设计
• 直到达到一个阶段性的目标，比如能编译一个最小的 C 标准库
• 开始写一个最简单的后端，至少能把绝大部分 AST/IR翻译成对应的指令，并且能链接出个简单的 ELF
• 反复优化，比如常量折叠等简单的优化，直到编译一些简单程序比如Fibonacci 不要比 Clang 慢太多

但是问题是，我们可以发现在这个过程里，其实真正需要“动脑”的部分，只有最开始的理解Spec 设计 Parser还有最后最重要的编译优化是比较有意思需要动脑的，剩下的任务几乎都只能用tedious 来形容。

也就是说“古法”编程的本质问题是，重复性的体力劳动占用了编码的太多时间，大大降低了生产力，而目前AI 的出现，正是为这些重复的体力劳动带来了新的转机。

^1: 虽然我阅读过很多 LLVM源代码，但是我不得不承认我没有完整做过一套流程

AI 带来的转机

AI 能做什么？

目前来看，我可以给出一个比较清晰的定义来描述 AI 能做的事情。

• 定义清晰：问题的输入和输出都非常清晰。
• 过程明确：由输入到输出的必要过程非常详细和明确。
• 反馈直接：做对/做错有明确的方法可以知道。
• 目标确定：做到什么程度算是可交付的状态

以上述写编译器为例：

• 定义：输入是 C89 源代码，输出是 ELF 文件（至少在 Linux上是这样），这个几乎是最简单的
• 过程：虽然编译器的架构多年以来已经基本稳定，LLVM 和 GCC的架构和设计有很多文档可以参考，但是目前 AI还是难以在没有前置知识的条件下直接明白最优的 workflow
• 反馈：在编译器开发里，问题往往是很容易发现的，毕竟有标准。
• 目标：这就是最复杂的事情，编译器除了本身编译原理的复杂度，还有用户体验UX 的复杂度，因此一个“好用”的编译器其实相当有挑战性。

恰巧最近 Claude 最近尝试用 Opus 直接 End-to-End 的 Vibe出一个编译器出来，本意是想说明 AI的进步[2]，但结果变成了大型行为艺术，出现了大量问题：

• 硬编码大量路径，包括 GCC的头文件，解释器路径，甚至连日期宏定义也能硬编码
• 无法编译 Hello World，大量 feature 完全不支持
• 大量的语义错误

结合我上面说的理论来看：

• 定义：AI 直接分析应该几乎是靠谱的
• 过程：我觉得 Claude应该就是在这一步出了大的问题，他显然没有像人类一样重复的去验证然后增量式开发
• 反馈：这个从结果来看还是没问题的
• 目标：这是另一个问题，显然 Claude也不知道一个“好用”的编译器的定义，至少他没有想到不能硬编码

但是如果反过来看呢？其实这些事情不是恰好和我们这些“古法”编程师互补吗？因此我想新时代下的“古法”编程师（或许应该叫做魔法师）的做法已经呼之欲出了：

只做创造性的工作，重复性的工作定义好这四点然后扔给 AI去做。

目前通过这个方式，我觉得 AI 能顶上差不多 25%个我的效率，所以我往往会让多个 AI 并行着帮我做事。而且 AI最大的好处就是任劳任怨干脏活累活。

^2: 或者是为了拉投资

完全的自动化写代码/科研

目前来看 AI的完全自动化编码，甚至是科研，我觉得有了很大的变量。整体来看，我持中立偏乐观的态度，原因有几条。

软工理论的革新

上述我讲的让 AI 工作效果变好的 4点，其实在以往软工理论里都有对应的研究，比如需求分析细化，自动测试等等，有了AI 的加持，这些事情会做的越来越 Practical。

我非常非常期待在这块有足够的突破，能把大部分常见的编码任务自动化的并且高质量的打包成我上述提到的四点，进一步解放生产力。

高质量数据的涌现

目前主流 AI厂商几乎或多或少，或承认或不承认的把用户对话数据拿去训练了。一个明显感觉的变化是，在GPT-4 时代，我让 AI 去写一个 Agent，即使给了很多上下文 AI也几乎很难写出来有用的代码（包括Prompt），现在一句话的事情就可以搓出来了。

LLM 的进步空间可能在缩小

目前 LLM 基础 reasoning能力见效快的方式（加数据量，加质量，加算力等）几乎都被尝试过了，我有一种感觉是目前亟待一些类似Transformer 一样 ground breaking 式的研究。但不管怎么样，我对 LLM的发展非常期待。

程序员会被替代吗？

目前来看 AI 想完全替代程序员还有不短的一段距离，比如上述做 Planning的能力仍然需要程序员的知识积累。举个例子的话，假设完成一件事情是从 A 到B 的一张图，现在 AI很多时候能选出最短路径，但是真实世界里很多时候并不是最短路径就能解决的。然而不得不承认，随着软工相应研究的深入，这些“古法”编程师的核心能力未来可能也会被AI 学会。

后记

我相信未来程序员不会被替代，但一定是会以一种新的形式存在，就像经过石器时代的人类并没有消失，只是学会了更趁手的工具提高了生产力。但是这种形式会是什么样的？开10 个窗口完全指挥 AI？还是像现在这样 AI的比重在工作流里不断提高但是最终还是依赖程序员审核？亦或者是 AI指挥人类干活[3]？具体的故事就等时间使之发芽吧。

^3: 参考文献 《心理测量者》

DeepSeekR1 是最近大火的大语言模型，主要是可以比肩 o1的性能以及完全开源。之前一篇文章所说，我手里有两台1T 内存的 EPYC 机器，因此正好可以用来部署 R1。本文主要记录一下利用llama.cpp 部署过程中的经验。

TL;DR: 对于 llama.cpp 以及衍生的 ollama部署方案，推理速度基本和内存带宽成线性，符合 Roofline 模型。

模型下载

llama.cpp 支持 GGUF 类型的模型，所以直接下载 unsloth做好的模型。

注意 R1 是 FP8 训练的，也就是说其中的 Q8就是满血版，也是我们这次要用的版本。

编译选项

如果是纯 CPU 推理，考虑到我希望有 -march=native来达到最大运算速度采用了本地编译：

1
2
3
4
5

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j install

这里 llama.cpp 会帮我们加上 -march=native。

如果是需要 GPU 推理，编译选项改为

1
2

cmake .. -DCMAKE_BUILD_TYPE=Release -DGGML_CUDA=ON
make -j install

运行

运行比较简单，我比较喜欢 llama-server 的方法：

1
2
3

llama-server -t 48 -m ./DeepSeek-R1-Q8_0/DeepSeek-R1.Q8_0-00001-of-00015.gguf \
             -c 4096 --no-mmap \
             --host 0.0.0.0 --port 9090

• --no-mmap 的话会直接把模型拉到内存里
• -t 48 使用 48 个线程
• -c 4096 context 设置为 4k

占用合计在700G左右，增大 context 会显著提高内存占用。

推理速度

内存带宽

我自己的服务器上推理速度有 2.5-3.5token/s，这个数值基本上和内存带宽是绑定的，可以用 mbw测试

1

mbw -n 128 256

这个测出来的数值乘以通道数量就是最大内存带宽，我这里有大概19926 * 16 = 318G/s。考虑 R1 是 memorybound，基本上推理速度会和最大内存带宽成线性。比如根据这里的汇报，使用DDR5 和 24 通道拥有接近 1T/s 的带宽，因此推理速度来到了 6-8token/s，提升几乎是线性的。顺带一提，这已经比很多纯 GPU 推理还快了。

CPU 加速？

上文中我只使用了 48个核心，一个想法是更多的核心会不会更快？可惜的是，R1 是完完全全的 memorybound，我尝试过 48，64，96，128四种配置，推理速度的偏差基本都在实验误差范围内，因此选择 48是完全足够了。

GPU 加速？

一个非常直观的想法是利用 GPU 加速，不过在实际操作前仍然要强调 R1是完全的 memory bound，也就是说如果不能把模型完全加载进入 VRAM的话至少还要把数据多来回拷贝两次。虽然理论上来说利用了闲置的 PCIE带宽，但是会抢 CPU 的内存带宽，所以未必能加速。下面实验基于一台双路 epyc7763 + 4xA100 的服务器测试 llama.cpp 的 GPU offload 效果。

• 纯CPU推理：1.8 token/s (~700G RAM)

这里更加印证了之前说的内存带宽问题，因为在多路 EPYC 上存在非常严重的NUMA问题（在2代上更加严重），因此他的等效内存带宽会很低。所以即使这台服务器的内存带宽有我自己服务器的2倍，推理速度直接打了对折。

• CPU + 8 layer GPU：3.0 token/s (~600G RAM + ~110G VRAM)

推理速度获得了近一倍的提升，根据观察推理过程中 CPU/GPU的变化，可以看到加速的来源主要是 A100 运算速度远快于 CPU，但是最后 textgeneration 的过程中 A100是完全闲着的，所以整体上仍然受制于内存带宽。

• CPU + 16 layer GPU：2.4 token/s (~510G RAM + ~206G VRAM)

随着把更多的 layer 放到 GPU上，推理速度反而下降了。不难猜测是更多的数据交换浪费了CPU的内存带宽所导致。

总的来说 GPU 应该是可以加速 R1 的推理速度的，但是：

• 推理速度大部分还是由内存带宽决定的
• 不是越多计算放到 GPU 越好，计算性能看起来也并不重要

因为 R1 是 MoE模型，也就是说每次不是全量权重参与计算，我猜测会有一个比较甜点的 GPUVRAM 大小，可能接近 90G 能达到最高的加速效果。

总结

对于 llama.cpp 这种 CPU + GPU 的方案，内存带宽越高，R1的推理速度会越快。

参考

• https://www.anandtech.com/show/16529/amd-epyc-milan-review/4
• https://x.com/carrigmat/status/1884244369907278106
• https://snowkylin.github.io/blogs/a-note-on-deepseek-r1.html
• https://digitalspaceport.com/how-to-run-deepseek-r1-671b-fully-locally-on-2000-epyc-rig/

自从开始读 Ph.D.之后，对算力的要求逐步增长，因此一直想购入强劲的服务器用于科研玩装机，感谢近几年的AMD 强势，我居然只用了大概 4 万元就拿下了两台 EPYC 7B13 64C128T + 1T内存的工作站，这篇文章就来简单分享一下整个实战过程和一些经验。

选购之前的功课

预算和渠道

购买工作站大概有三条渠道

• 向正规服务器提供商购买整机：拥有完整的保修（甚至上门哦！），硬件兼容性还有软件问题基本无需操心，但是费用是最贵的，典型的提供商包括戴尔，联想等。由于此类渠道一般只有toB，个人消费者很难接触到。
• 在零售渠道购买含保修的散件：一般服务器硬件尤其是 CPU是不对消费级市场开放的，然而 AMD 的 HEDT平台，也就是线程撕裂者打破了僵局，最新一代线程撕裂者比如 7980X提供了相当可观的算力。一般可选的平台包括京东和亚马逊等，可以提供完整的保修，但是性价比相当感人。
• 在淘宝购买店保的二手散件（或者整机）：由于 CPU一般不会损坏，因此有大量淘汰下来的服务器配件流通于淘宝上，一般这些散件基本接近成本价，相对应的也只有比较少的技术支持和保修。

举个例子来说，目前京东在售的 64C128T 的线程撕裂者 5995WX 价格为 49599元，在淘宝一颗 64C128T 的 7763 大概只需要 10000元左右，然而他们的多核性能相差大概在 10%以内，由此可见淘宝散件的价格优势。

考虑到我贫瘠的预算，因此我只能选择在淘宝上购买散件。

计算任务

确定了购买渠道和预算后，更重要的事情就是确定自己预期的工作负载，因为不同的负载对整个系统的设计完全不一样。以我自己为例，我不需要任何GPU算力，因此我可以考虑更小一些的机箱，也不用担心显卡挡住内存插槽等，但是相应的我需要大量的核心数量和内存数量，因此我需要考虑内存通道数量和频率等。具体的事项会在后文中说明。

除了是否需要 GPU，还有就是要确认自己的程序是否存在以下瓶颈：

• 并行度：决定了是否需要更多的核心
• 内存速度：决定了是否需要高频率低延迟内存
• 计算速度：决定了是否需要单核心性能

淘宝店铺选择

淘宝有非常多的店铺提供二手服务器散件，本文不作任何推荐，但是我个人的标准是：

• 回复足够及时，一般首次咨询半个小时内没有回复我就会直接 pass不再考虑
• 店龄、店铺等级、店铺资质等
• 接受发货前测试
• 没有明显的差评

这一点每个人都可以有不同的标准，个人建议是大部分配件在一家买齐测试好再发货节省来回的运费和时间，我选择的店铺甚至很贴心的提供了远程桌面随意测试，大大节省了中间的时间（不过仍然出现了意外，下文会提到）。

配件选择

CPU

CPU 几乎是最重要的配件，他决定了可以选择的主板还有 PCIE通道数量和可选的内存。

首先简单介绍一下 EPYC 的命名规则，以 7503 为例，其中的 3 代表第三代EPYC，5 代表了核心数量，0 代表了单核心的性能。但是有一些 EPYC 的 CPU第二位是字母，这代表 OEM 定制版本，一般是特定公开版本的 EPYC型号的特挑版本。

我的需求是越多核心越好，单核性能并不是太需要，考虑到性价比最后选择了EPYC 7B13，这是阿里和 Google 的定制版，但是 Google 版本是 60 核心 60线程，阿里版是 64 核心 128 线程，基本确认是 EPYC 7763的马甲但是多核性能要差一些，主要体现在频率上。

另外需要留意的是，EPYC 双路存在严重的 CCD延迟问题。和消费级不一样的是，他是第二个 socket 上全部都慢的离谱。

主板

下一步就是选择主板，对于我来说可以买到的只有

• 技嘉 MZ32-AR0
• 技嘉 MZ72-HB0 （双路）
• 超微 H12SSL-i
• 超微 H12DSI-NT6 （双路）
• 永擎 ROME2D16-2L （双路）

其中超微 H12DSI 支持双路 CPU，本来我是打算选择这个，因为可以直接 256T+ 2T，但是很快我注意到了双路主板在塔式机箱内上两个 280W CPU 时存在大量的VRM过热死机的汇报。因此我只能把原来的单台计划变为两台单路减少散热压力，然而超微的主板E-ATX 孔位和标准孔位不兼容，需要自己改机箱，所以最后选择的是技嘉MZ32-AR0 （甚至还有全新存货）。

一旦选择好主板，就可以前往相应的页面插具体的参数，包括并不限于：

• 内存通道数量
• 内存最大频率
• PCIE 数量
• M2 接口数量，SATA 数量

内存

首先内存有几大类：

• UDIMM：无缓冲内存，常见于消费级，由于没有缓冲，对信号完整度要求高因此容量相对较小频率较高。目前市面上最大的一般是32G。
• RDIMM：有寄存器的内存，简单来说就是等信号全部到了再去读写，对信号完整度要求稍微低一些，因此可以支持更大容量，但是延迟和发热会有显著增高。目前市面上我见到最大的有256G 的内存条。
• LRDIMM：进一步增加了缓冲来提升单条容量。

目前三代的 EPYC 只能插 DDR4，而且根据主板的说明书当插满 RDIMM的时候最高频率仅支持到 2933MHz，因此可以节省一点买更高频率内存的钱。总的来说，高频率、高容量和低延迟几乎是不可兼得的事情。

这里还有一条需要注意的就是 ECC，目前市面上所有 RDIMM 和 LRDIMM内存都是有 ECC 纠错的，但是这不意味着出现 ECC错误是正常的！我在收到货测试时才发现有几根内存条会固定出现 ECC错误，虽然不影响数据的正确性，但是一般这意味着内存颗粒已经出现了问题，应该尽快找商家更换。

此外由于 RDIMM 多了一个控制芯片，高温时也会出现 ECC错误，因此需要查阅相应的内存条文档确认工作温度。

为了测试内存条的稳定性，推荐烤机软件为：

• AIDA64 （注意烤机时关闭页面文件！不然系统会卡死）
• prime95 （Linux下有等价实现）

这里反而不推荐 memtest86+，在我测试的时候他甚至没有触发 ECC错误，而且耗时极长，难怪 archwiki 把他归类为压力不大的测试项目。

电源

电源几乎没有什么好说的，我选择的是 LEADEX 的HG850W，趁着活动的时候低价入了两个。我个人计算习惯是：

• CPU：TDP 瓦数，这里是 280W
• 内存：10W 每根
• 机械硬盘：25W 每个
• SSD：10W 每个
• 主板：50W

基本上我都往多了算， 850W 是绰绰有余的，一般留个 10%左右的余量就可以。唯一比较坑的就是，技嘉这个主板的主板供电居然是在正上方，电源的主板线很容易够不到，完全没法走背线。

存储

存储这一块我遇到了三星 SSD 和部分 SATA Controller 的兼容性问题以及国产 SSD 普遍采用的 MAP1602 主控的 Linux 兼容性问题。目前两个问题在最新的Ubuntu 2204 中应该都得到了修复，反而是 Ubuntu 2304 因为不是 LTS 有一些fixes 没有 backport。

另外值得注意的是技嘉这个主板的 m2 只有 pcie3.0。

机箱和散热

以往装机，这两项并不太重要，但是上面很多地方都提到了温度对系统稳定性的影响，因此在选购工作站的时候务必要对散热上心。

首先是机箱，我在选购的时候出于便携和空间限制选择了塔式，如果有机房的话可以选择正常服务器尺寸获得更好的散热，以下经验都是基于塔式机箱展开。

机箱型号我选择的是追风者614pc，看中的是存储扩展性和自带俩风扇。其实机箱型号不重要，重要的是机箱风道。具体来说，我在开放式环境仅安装CPU 散热器时，内存条温度可以达到97度（标准工作温度上限为95度）触发 ECC错误，但是只要稍微加一个平行于内存条风向的风扇，温度瞬间降低到60度左右，这个效果对于机箱内大部分需要散热的配件都是一样的。

另外和平时的装机不同，CPU 的散热一般是不需要太多担心的，我购买的是Coolserver P42 也就是金钱豹散热器压住 CPU基本上没有任何压力。相反，需要注意的是 VRM也就是供电模块的散热，比如我购买的 CPU 有整整 280W 的 TDP，而 CPU电压一般才 1.2V 左右，也就是说通过 VRM 的电流非常大会迅速产热。一般来说VRM 100 度时变会主动降低供电来减少发热，在 AMD的定义里这个属于硬件降频无法控制，当 VRM 温度超过 110左右时基本会直接报警关机。因此一个良好的机箱风道至关重要，这里推荐在 B站搜索相关视频了解，比如硬件茶谈这一篇。

最后我选择的散热方式是一共 7 个风扇，前面板 3 个进气，后面版 1个出气，上面板 2 个出气，下面板 1个进气，在极限烤机状态下，整个系统可以稳定运转，美中不足的就是仍然会有少部分时间触发VRM过热降频，目前根据我了解的信息，只能定制配件散热，所以留给之后的自己吧。

网卡

技嘉这个主板有 OCP 接口，正好之前有海外过来的万兆网卡 CX341a 是 OCP接口只要 15 块一张，配合 DAC 线完美的实现了两台机器间的 10 gb 网络。

总结

这次购买服务器从有想法到最终实操一共花了一个半月，要感谢的就是另一半的大力支持和TUNA群友们的耐心，学习到了很多也玩的很开心，希望这两台服务器能在未来的时间里发光发热吧。

数框框！

参考

• AMDRyzen™ Threadripper™ Processors
• 最强桌面级处理器，有多快？AMD线程撕裂者 7980X/7970X简测
• 7B13
• Ibuilt a dual-Epyc 7773X server ! It’s FAST, and now in V3.0 (updated 2,with pics)
• 280WEPYC双路服务器主板选超微H12DSI还是技嘉MZ72-HB0
• Overheatingproblems with 2x Epyc 7742 in Define 7 XL 1TB/2TB RAM
• Samsung860/870 SSDs Continue Causing Problems For Linux Users
• 国产SSD主控联芸MAP1602，Linux兼容性解决方案
• MAP1602Ubuntu Backport
• 傲腾内存预热：什么是RDIMM和LRDIMM？
• StressTesting
• 【硬核科普】机箱风扇怎么安装，如何科学的布置机箱风道？
• AMD3rd Gen EPYC Milan Review: A Peak vs Per Core PerformanceBalance

总算是通过了 ETH Zurich Master in Computer Science除了毕设外最后一门课，借着这个机会来介绍一下这个项目的体验还有课程评价。

（下文会用 MSCS 来代替ETH Zurich Master in Computer Science）

总体评价

我会尝试从多个维度评价 MSCS来尽量还原一下这个项目的体验。对课程评价感兴趣的可以跳转到后面一节。

培养方案

虽然 MSCS 宣称 Major + Minor 的灵活选课模式，即只要修够了 Major的学分和任何一个 Minor 的学分即可毕业，但是事实上：

• Minor 之间以及 Minor 和对应的 Major 重合度非常高
• 有些 Minor 分布不均匀，比如 Networking 有 75% 的课开在一个学期，只有25% 的课在另一个学期。

我个人觉得 Minor 的区分意义真的不是很大。

学习强度

ETH 一个学分对应 30 个小时的学时，而 ETH 一个学期（教学周）只有 14周，这也就意味着如果只考虑工作日学习 8小时，一个学生一个学期最多只能学习 14 * 5 * 8 / 30 = 18个学分，即使包括休息日每天学习 10 个小时，一个学生一个学期最多也只能学习32 学分左右。然而 MSCS 整整有 120学分！也就是说，按照前面取工作日的估算，至少需要 3 年才能毕业MSCS。事实上，我在和一位教授聊天的时候，也得到了相同的评价：

(ETH Computer Science Master) ... is absolutely one of the mostintense master programs over the world.

要想通关 MSCS 也最少需要 3 个学期，因为在培养方案里存在一条长度为 3的关键路径：2 个 Lab -> Practical Work -> MasterThesis。然而，即使我事实上在课程上花费的时间远远小于 30小时/学分，对我来说 4 个学期通关已经是极限了。这里引用 r/ethz的名句：

are you studying? no? then go study.

可以说 ETH 的学习强度是独一档的。

科研氛围

每年瑞士有一半的科研经费会涌入到 ETH 中，2019 年这个数字是 25亿美元的一半，因此瑞士的 PhD有着在全世界一骑绝尘的工资以及非常浓厚的科研氛围。这里的科研资源真的非常丰富，而且所有人都是静下心在做扎实的工作。

如果有兴趣在瑞士做 PhD，最好的办法就是 Semester Project 或者 Thesis和心仪的组合作先互相了解，因为科研资源丰富，这边通常会有足够的题目给学生来做，甚至有时候一些科研项目会下放到教学中。经常可以见到的例子就是某门课的Project 最后变成了一篇非常不错的 Paper，科研资源的丰富可见一斑。

个人吐槽

好了，优点基本都说完了，接下来就是我个人对 MSCS 不满意的点：

首先课程压力极为繁重，竞争非常残酷。4 个学期毕业意味着每个学期平均是30 学分，前文已经提到了，按照 ETH的设计在教学周内是几乎无法完成的，所以学生如果想早点毕业，那就不得不再额外抽出休息时间学习，然而一个更残酷的事实是，即使你已经花了很多时间了，仍然会有学生比你更拼:)。

其次就是性价比低。前面提到了，MSCS 通常通关速度也就是 4个学期两年，这已经比绝大多数 Master项目长了，更别提一个不小心就有可能会延长学习时间。当然有的人也会说，学到的东西也更多了，可是对我来说我真正感兴趣的课程少之又少，很多时候要么是学习已经非常熟练的知识，要么就是硬着头皮学习毫不感兴趣的知识，我认为这样反而会分散我的精力。

最后就是开学前考试的奇葩制度。前面提到，理论上教学周的时间是无法完成教学任务的，或许是为了解决这个问题，在ETH 是没有真正意义上的寒假和暑假的，只有从学期结束到考试前的lecture-free period。没错，在 ETH本学期的考试是在下学期开始前完成的，而理论上中间的时间只是用来复习而已，再加上peer pressure 基本上压力会在 MSCS的学习循环（学习周-复习-考试-学习周）中一直持续。

总的来说，如果满分100分，我只能给 MSCS 打个 70 分。

课程评价

在具体评价之前，有几点需要说明：

• 我个人技能树主要是 System方向，包括并不限于操作系统、编译器等等，但是对 AI几乎一窍不通（仅了解最基础概念，会用PyTorch），因此在选课口味和评价上会有非常大的偏差，所以要注意同一门课适合的人也是不一样的。
• 我只会去我感兴趣的线下课，上面已经提到了我感兴趣的课程非常少，所以下面的绝大多数课我都没有去过线下，有些体验可能不完整。
• 我会着重于“性价比”的评价，基本可以用grades / (efforts per credit) x 100%这个式子来定义，毕竟及格万岁:)。

Information Security Lab

内容上主要是写代码解决一些问题，HS21是EllipticCurve、TLS、Cryptographic Reductions、TEE、SoftwareSecurity、DDoS这几个部分：

• EllipticCurve：我倒数喜欢的crypto，主要是实现基础椭圆曲线，意外的很友好，看PPT完事。TLS实现：我前几喜欢的Network，但是最垃圾的Lab之一，要求实现一个简易TLS协议，示例代码不仅出了很多纰漏，描述也不清不楚，工作量大，性价比最低。
• CryptographicReductions：倒数喜欢的crypto+1，说白了就是做数学题，很多题具有脑筋急转弯的性质。
• TEE：个人觉得非常无聊的Lab，我不知道这些东西和TEE有什么联系，如果TEE就是做这些事情的话也太简单了，但是比较简单划水的一期。
• Software Security：简单来说就是打CTFPwn，如果打过比赛的话难度基本为0，不然的话会很吃力。
• DDoS：出于个人时间原因我跳过了，所以不评价，但是我简单扫了一眼pdf感觉还凑活，相比前5个Lab最大的优势是有即时反馈，并且保证分数不低于反馈分数。简单来说是ACM和OI的区别，大大降低了心理压力。

整体难度中等，但是非常消耗时间，每两周一个DDL。给分的话我觉得只要时间花到了及格问题不大，性价比中等。

Hardware Security

噔 噔 咚！

内容上介绍了近些年来 CPU 和 Memory 相关的攻击实现，比如RowHammer，Meltdown这些。教授本身就是做这个方面的前沿所以讲起来非常ok，是我目前出勤次数最多的课，也是我在ETH 最喜欢的课之一。

难度上比较高，形式是前半个学期每周一次DDL实现attack，后半个学期两周一次 Project，最后两周做开放式 Research，和 ISL一起选的下场就是每周都有至少一个大 DDL，如果 System比较吃力的同学不要像我一样作死。

给分总评全班最低分是5.0，根据某个同学的说法，可能是过于Push自动筛选掉了不能拿5.0的学生（笑）。

上图是代码量。个人认为性价比偏低，但是这个 topic 对我来说太棒了。

Concepts of ObjectOriented Programming

这门课我修的时候是纯网课，比较羞愧的是我一学期没有学过一分钟，考试前几天速通，但是非常非常意外的是这是一门非常优秀的课！一方面教授很好的把复杂的概念用非常清楚的逻辑还有适当的例子讲了出来，另一方面这门课很好的解答了语言设计中Why 的问题，比如我写了很多C++，这是我第一次思考我在做inheritance的时候是在干什么。

难度我觉得适中，比较偏理论，如果对C++、Java、Python、Scala、C#中至少三门熟悉的话上起来会比较轻松，不然的话会浪费很多时间复习语言特性。

原来有期中考试加分，我选的时候只有一次期末考试了，因为非常感兴趣所以分数还不错，性价比整体比较高。

Advanced Topics inCommunication Networks

主要是讲 MPLS 和 Traffic Engineering，搞 homelab的垃圾佬应该会喜欢听，我去过几次线下课。Project 主要是写 P4 搞SDN，简单来说就是给交换机编程实现课程上讲的网络协议，去年的课程是 FRR +P4 + OSPF 明显有趣一些，HS21 不知道为什么把 FRR 和 OSPF 砍了。

难度的话需要对 network 有一定基础才能比较快乐，比如如果连 OSPF 和 BGP的区别都反应不过来那我不建议选这门。

给分的话 Project 给分最低分是5.25，但是期末考试给分感人。据一位朋友说，这个老师的课 5分已经算非常高的分了，再考虑到 Project 的工作量，性价比属实很低。

Reliable andTrustworthy Artificial Intelligence

是我更讨厌的 AI ，为了混学分选的。内容主要是讲 Adversary attack和对应的Verification，全都是这个教授自己的研究成果，其实还是挺有趣的，但是我个人觉得讲的过于简略，想完全搞懂需要去读他的论文。另外有部分分数来自Project，主要是实现他课上的算法，比较有趣。

难度的话我觉得主要来源于老师讲的不太清晰，可能有基础的同学会更加轻松，至少我非常吃力。

给分是30%的 Project 和70%的期末，HS22据说难度进一步增加了，考试一片哀嚎，不过 Project给分很不错，性价比中等吧。

Advanced Systems Lab

第二门 Lab，主要是理解如何对 CPU Performance进行建模和测量，非常有趣的一门课，由 Project、Midterm 和 Homework组成，其中 Project需要组队利用课上的知识去实际解决一些性能相关的问题比较有挑战性，Homework基本是送分，Midterm 我没有考太好不过影响不算很大。

整体难度不算很高，也基本不需要太多的前置知识，占用时间虽然很多，但是整个学期下来看的话比较平均，因此性价比也中等。

Advanced Operating Systems

操作系统课，从底层实现一个微内核系统，基本要实现所有操作系统中涉及到的概念，包括串口编程、内存管理、多核同步等等，形式上和Hardware Security 类似，组队每 1 - 2 周一个DDL，最后会有自选题目，比如我选的是网络栈实现，最后是整个班唯一一个把带宽跑满的实现:)。

整体上可以说这门课比 Hardware Security 还要stressful，但是含金量极高，可以说秒杀其他任何一门课。除了操作系统的各种核心概念，C语言调试能力，代码抽象能力都可以锻炼到，然而美中不足的是，一门我每周要花差不多2 - 3 天的课竟然只有 7 学分？！在我看来这门课应该至少值 14学分的工作量。总之，如果 C语言基础不佳，或者对操作系统没有足够的了解（注意这是货真价实的Advanced）慎选这门课，即使最后做下来很有成就感，获得的学分也和付出完全不成正比，性价比极低。

ProgramAnalysis for System Security and Reliability

介绍了程序分析常见的技术，和 RTAI一个老师，因此风格也类似，课程内容基本都是自己的研究成果，但是和 RTAI不同的是这门课的 topic 我更加熟悉一点。给分是 50% 的 Project 和 50%的考试，Project 是用 Souffle实现污点分析，可以 2 人合作但是我是 1个人做的，难度不算很高但是细节非常多。至于考试，基本和 RTAI一个风格，比较难。

整体上性价比和给分还不错，但是考试太难是一个很大的减分项。

Network Analysis

这门课是 GESS课，简单来说就是社会科学相关的课，在培养方案中必须修一门。课程内容主要是对图的一些分析，涉及一部分图论知识，个人感觉更像是数学课，基本不用什么编程，形式上期中考试3 道题然后期末考试 6 道题，每道题 10 分，取其中最高的 6个求和得到总成绩除以 10 然后按照 0.25 进位得到最终成绩。

注意这门课 lecture 和 slides 都没什么用，直接看 notes备考就可以。

一共 3 个学分，我花了大概有 50小时在上面拿的分数也比较合理，性价比一般吧。

Research Topics inSoftware Engineering

这门课是 Seminar，也是培养方案中要求的课程之一。所有的 Seminar形式都是类似的，会给出一个列表的近期 Paper，学生选择后做一个 30分钟左右的汇报，教授或者助教根据汇报的质量进行打分，同时课堂参与（包括出勤）也会占一部分分数。

一般来说并不需要 2学分对应的工作时间，性价比算高的，如果最后少几个学分毕业可以考虑多选一门。

Applied Security Laboratory

这门课是用来替代 Practical Work的课程。内容上主要是两部分，第一部分是独立学习他们给的一本手册，里面会介绍一些Security Principles和常见的攻击防御，第二部分是组队开发一个系统来实践之前的Principles，最后所有的小组会互相评测系统。这门课最有意思就是组队开发的系统必须要留两个隐秘的后门，然后评测的时候需要利用学习到的知识来挖掘后门，尤其是还会发现一些无意间留下的后门，最后Pre 的时候看大家互相挑错还是很有意思的。

整体上难度不算很高，工程量非常低因为课程的关注点是 Principles的应用而不是开发能力，尤其是当时我们评测的系统85%的功能都没实现也没什么问题，考虑到其他的Lab 或者是 Semester Project 的工作量，性价比着实很高，就是比较难抢。

System Security

介绍系统安全的课，整体上深度比较浅，但是覆盖的面非常广，基本上涉及了所有常见的系统安全问题，最有意思的是涉及了TEE 相关的攻击，在其他课程里基本很少见，不过 HS22删掉了缓存相关的攻击有一点遗憾。给分是 20% 的作业和 80%的期末考试，作业如果打过 CTF应该比较简单，我基本都是一个晚上就搞定了，考试的话难度并不高，但是题量比较大。

整体上难度中等，据说一般给分不会很高，但是通过的话也不太需要非常多的努力，所以性价比还算不错。

Design ofParallel and High-Performance Computing

这门课的内容和之前的 Advanced Systems Lab 有 40%左右的重合因为有同一个教授，因此先修任何一门再修第二门都会轻松一点。另外60%的内容主要是并行、内存模型和锁相关的知识。整体上不算特别难，但是比较偏理论，最有价值的是内存模型相关的知识，这是我第一次真正理清各个概念之间的关系。给分的话是50% 的 Project 和 50% 的考试，Project的话是从助教给的题目中选一个合作开发最后提交报告，考试相对来说不算特别难，而且每年的题型比较固定，好好复习问题不太大。

整体难度中等，但是有整整 9 个学分，因此性价比非常不错。

Informal Methods

为了混学分选的，但是意外的还不错的一门课。整体课程设计是 COMP6721的子集，有兴趣提前了解内容的可以参考其指导书，ETH这门课只 cover 了其中 50%左右的内容，主要包括如何用类似形式化的方法去证明程序没有错误，以及一次性写出正确的程序（比如二分法中加一在哪里，要不要带等号等问题）。考核是三次作业分数取平均值，前两次作业只要好好听课看notes 都比较简单，印象里大概各自只花了 1 - 2天就可以拿到快满分，最后一个作业工作量大也比较难，我花了大概 2周在上面（会留包括寒假在内约1个多月的时间完成），但是给分整体上都比较宽松，最后我拿了快满分。

最大的问题是答疑速度非常缓慢，moodle直到结课了还有不少问题助教根本没有回复过，基本上只能依赖邮件直接去问和同学互助。另外这门课没有slides，老师是直接板书类型的，课后能看的只有手写的一些notes，因此上课非常非常重要，我个人经验是上课 2小时能弄懂的话可以节省课后 4 - 8 小时的时间。

整体上性价比比较高的一门课，主要是不太占用教学周时间，第三次作业可以寒假慢慢写。

一些小知识

• ETH 出分的 DDL 一般是 gradingconference，最晚应该不晚于开学第一周的周五
• 关于 grading conference，VIS那边说基本就是让差一点及格的学生能及格的过程，算是“公开的秘密”，另外也有TA 透露过他们也会尝试给学生“找分”
• 虽然 Practical Work 和 Thesis都需要很多前置条件，但是事实上只要联系教授和 Studies Administration一般总可以注册上，不过缺少 Practical Work 去注册 Thesis我的确没有听说过，事实上也比较难以双开
• 迟到了也可以参加考试，给 exam office 打电话如果需要帮助
• 超过期限想要加考试/退考试也是可能的，给 exam office 打电话
• graded semester performance如果不退课会在成绩单第二页(addendum)上留下 fail，session exam 不去会留下no show
• 不注册 session exam 的话这门课不会出现在成绩单上
• 在 ETH一门课只能重考一次，因此如果挂了两次这门课就不能再修了，如果恰好是毕业必修的课而且没有替代，那就毕不了业了
• 但是在出分前的重考似乎是不算的（此条没有确证过，因为一般教授很少会在当期组织重考）
• ETH 最近有一个内部的评课系统可以参考

后记

MSCS的学习真的是一趟压力非常大的旅途，我不是一个抗压能力特别好的人，感谢一路上有天下第一可爱的女朋友的陪伴和支持，我们都会变得更好的！也祝各位学业顺利！

引用

• EPFLreportedly seeks bigger slice of federal funds
• MSCS2020
• GradingSystem
• ECTS
• VVZ
• Degreerequest

Datalog 是一种由 Prolog 分化而来的逻辑编程语言，相比 Prolog最大的不同在于 Datalog 对于语法做出了很多限制因此是非图灵完全的，然而Datalog 仍然在数据库和程序分析中有着广泛的应用。Souffle 是 Datalog的高效实现之一，之前在北大熊英飞老师的公开课上曾经见过但是那个时候不理解也不太会写，最近修程序分析的时候又一次遇到，大作业被迫写了一千多行，因此本文就是用来记录一下Souffle 编程的经验。

本文的代码可以在 Souffle 的在线编译器中运行。

For English version of this post, see this.

图可达性求解

和一般的命令式语言不同，在 Souffle中主要的编程对象是“关系”。简单来说，程序员给定输入和输入之间的关系以及规则，之后Souffle 会根据关系自动推导出输出结果，下面用一个例子来说明。

1
2
3
4
5
6
7
8

.decl edge(n: symbol, m: symbol)
edge("a", "b").
edge("b", "c").
edge("c", "d").
.decl reachable (n: symbol, m: symbol)
.output reachable
reachable(x, y):- edge(x, y).
reachable(x, z):- edge(x, y), reachable(y, z).

这个程序会输出一个有向图里每个节点所有可达的节点，接下来逐行分析。

1

.decl edge(n: symbol, m: symbol)

在 Souffle 中 .decl 表示声明一个关系，Souffle 支持symbol 和 number 作为数据类型，其中symbol 其实就是字符串类型。

1
2
3

edge("a", "b").
edge("b", "c").
edge("c", "d").

这三行表示对于 edge这个关系，有三个关系是已知的，这些已知的关系也叫作 facts。

1
2

.decl reachable (n: symbol, m: symbol)
.output reachable

这一行声明了一个新关系 reachable，并且用.output 来输出这个关系。

1
2

reachable(x, y):- edge(x, y).
reachable(x, z):- edge(x, y), reachable(y, z).

这两行就是定义关系的规则了，他定义了两件事：

1. 如果 x 和 y 之间存在一条边，那么 x 可以到达 y
2. 如果 x 和 y 存在一条边，并且 y 可达 z，那么 x 可以到达 z

看起来非常的符合直觉，但是为了进一步理解 Souffle的原理，这里要强调两个隐藏语义：

1. :-右边的变量如果出现在左边那么具有“任意”的语义，比如第一行中的 x 和 y表示的任意 x 和 y
2. :-右边的变量如果没有出现在左边，那么具有“存在”的语义，比如第二行右边的y

结合这两点，其实第二行的含义具体说应该是：对于 reachable关系中任意的 x 和 z ，如果存在一个y，满足 x 和 y之间有一条边并且 y 可达 z，那么 x 可达 z，即满足reachable。

这样理解的话虽然看起来是更复杂了，但是可以帮助接下来理解 Souffle是如何求解这个问题的。

原理

为了更好的编写 Souffle 程序，现在一个很重要的问题是 Souffle怎么实现求解上述程序的？注意 edge 和 reachable的实际含义都是我们人为加上去的，在 Souffle眼里只有关系和规则而已。为了解答这个问题，需要引入不动点的概念，简单来说就是给定一个集合S 和一个作用域和值域都是集合的规则 g 有：

\[S = g(S)\]

那么 S 就是一个不动点。

Souffle 实际上求解的过程就是根据已有的 facts不断的应用所有定义的规则，直到所有集合达到不动点，以上述图可达性的例子来说明：

1. edge 关系没有定义规则，因此 edge 的不动点集合就是所有的 facts，即(a, b), (b, c), (c, d)
2. 反复应用 reachable 第一条规则，可以把 edge 关系中所有的 facts 添加到reachable 中，即 (a, b), (b, c), (c, d)
3. 应用 reachable第二条规则，注意之前对这条规则的解释，可以添加几个新的 facts 到reachable 中，即 (a, c), (a, d), (b, d)，此时 reachable关系的集合为(a, b), (b, c), (c, d), (a, c), (a, d), (b, d)
4. 反复应用源代码中所有的规则，所有集合不再变化，程序结束。

局限

不动点算法可以在很多场景下用 Souffle写出非常符合直觉漂亮的代码，但是相应的其也有局限性：

上面解释不动点算法的时候有一个很强的假设，那就是g必须是（非严格）单调递增的，放在Souffle里就意味着如果规则如果存在环形依赖，那么这个环里不能出现否定，这样才能保证所有的规则是单递增的。也就是说，下面的程序Souffle 无法求解

1
2
3
4
5

.decl p(x: number)
.decl q(x: number)

p(x) :- !q(x).
q(x) :- !p(x).

此外，为了能表达更复杂的语义，比如一对多的关系，Souffle提供了一部分复杂数据结构比如链表的支持：

1
2
3
4
5
6
7
8

.type IntList = [next: IntList, x: number]
.decl L(l: IntList)
L([nil,10]).
L([r1,x+10]) :- L(r1), r1=[r2,x], x < 30.
.decl Flatten(x: number)
Flatten(x) :- L([_,x]).
.output Flatten
.output L

然而相比常见的命令式语言，无论是声明还是使用上显然都不太方便。

最后，除了链表这样复杂的程序结构，我发现还有一类关系是 Souffle比较难以表达的，那就是元素聚集相关的逻辑，比如假设我们定义“如果一个店铺卖的苹果价格全部小于25，那么这样的店铺我们称之为便宜店铺”，并且给定facts：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

.decl apple(price: number, shop: number)

apple(10, 1).
apple(23, 2).
apple(32, 2).

.decl cheapApple(price: number, shop: number)

cheapApple(price, number) :-
    apple(price, number), price <= 25.

// A cheap shop only sells apples cheaper than 25
// and thus only shop 1 meets this requirement.
.decl cheapShop(shop: number)

直觉上可能会写出：

1

cheapShop(shop) :- apple(x, shop), x < 25.

但是很不幸这是不对的，因为其中 x 具有存在语义，所以店铺 2也会被算在其中。确切来说在这种情况下，很难找到一种合适的方式表达“某个店铺中任意苹果的语义”，因此只能用count来曲线实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

.decl cheapCount(shop: number, cnt: number)

cheapCount(shop, cnt) :-
    apple(price, shop),
    count : { cheapApple(_, shop) } = cnt.

.decl appleCount(shop: number, cnt: number)

appleCount(shop, cnt) :-
    apple(price, shop),
    count : {apple(_, shop)} = cnt.

cheapShop(shop) :-
    appleCount(shop, cnt),
    cheapCount(shop, cnt2),
    cnt = cnt2.

.output cheapShop

然而 count 也并不是万能的，因为很容易写出 witness问题，这里不做展开了。

UPDATE(2023/02/19)：正确方法不是 count，是先对要证明的 property取反把存在语义变成任意语义然后再用 Souffle 编程解答。

后记

Souffle是一门非常有趣的语言，而且在写文的这个时间点仍然在积极开发，性能也非常不错，然而我最后作业还是选择了用Python 实现，原因主要就是上面提到几点局限性，不过 Souffle整体编写体验还是很不错的，在很多地方都符合直觉，希望发展的越来越好。

参考资料

• Prolog Wiki
• DatalogWiki
• Souffle
• SoftwareAnalysis Fall2020
• Leastfixed point Wiki

For English version of this post, see here.

一般来说，一个用 C写的库可能会暴露接收一个函数指针作为回调函数，比如：

1
2
3

typedef void (*callback_t)(void* data);

void register_callback(callback_t callback, void* data);

然后我们可能会这样使用这个接口：

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

typedef struct Context {
    int id;
} Context;

void callback(void* data) {
    Context* ctx = (Context*)data;

    printf("Context id=%d\n", ctx->id);
}

int main(){
    Context* ctx = malloc(sizeof(Context)); 
    ctx->id = 114514;

    // some operation

    register_callback(callback, ctx);

    // other operation

    free(ctx);
}

但是这样仍然不太方便，因为我们需要手动管理 data指针的生命周期，一不小心就有可能会内存泄漏。

Closures

如果熟悉 C++ 的话，把这个接口用 std::function包装一下基本上不会费太大的力气：

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

typedef std::function<void()> callback_fn;

class CallbackManager {
public:
    static CallbackManager* New(callback_fn fn) {
        return new CallbackManager(fn);
    }

    void operator()() {
        return this->_fn();
    }

    ~CallbackManager(){
        delete this;
    }
private:
    callback_fn _fn;
    CallbackManager(callback_fn fn) : _fn(fn) {}
};

void register_callback_wrapper(callback_fn callback) {
    CallbackManager* mgr = CallbackManager::New(callback);
    register_callback([](void* data){ (*(CallbackManager*)data)(); }, mgr);
}

然后我们就可以把之前的代码变得更加 modern 一些。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

typedef struct Context {
    int id;
} Context;

int main(){
    std::shared_ptr<Context> ctx = std::make_shared<Context>();
    ctx->id = 114514;

    register_callback_wrapper([ctx](){
        // play with Context without any concern.
        printf("Context id=%d\n", ctx->id);
    });

    // no need to free context.
}

现在我们可以传入一个 std::function也就是一个闭包作为回调函数，并且享受到 C++ 各种 modern 的工具。

一个闭包一般来说就包括一个函数指针和对应的上下文（比如捕获的变量等等），而原来接口签名中的callback 和 data 就对应了这两点。

裸函数指针

但是， 并不是所有的回调函数 API 都像这样设计。比如：

1

void register_callback_bad(callback_bad_t callback);

它只接受一个裸函数指针，意味着我们不能传入一个闭包因为没有地方存放闭包的上下文。类似的，C++不会允许把 lambda 转换成函数指针如果它捕获了任意变量。

所以我们面临的挑战是：我们可以把一个闭包退化成函数指针吗？听起来不太可能但是最近我发现libffi 确实实现了这一点。

After calling ffi_prep_closure_loc, you can castcodeloc to the appropriate pointer-to-function type.

让我们看看 libffi 背后的技巧。

libffi 实现

Idea

正如上面所解释的，一个函数指针仅仅是一个地址，运行时并不携带任何和回调函数相关的上下文。因此，唯一的解决方案是分配一些静态内存然后在回调函数里访问，但是我们仍然需要办法区分不同的回调函数。你可能已经猜到了，没错，尽管不太常见，函数指针本身的地址可以作为一个唯一的标识。

基本上，libffi的想法就是用额外的内存来存储闭包的数据，但是实际的设计非常有意思。

Trampoline

实现的核心概念是 Trampoline，每个trampoline 包括两个重要的字段 code 和data。其中 code是注册的回调函数的入口点。它在内存里会有多份，所以会有多个不同的地址。data是和回调函数对应的数据。下面是相关代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#ifdef ENDBR_PRESENT
# define X86_DATA_OFFSET4077
# ifdef __ILP32__
#  define X86_CODE_OFFSET4069
# else
#  define X86_CODE_OFFSET4073
# endif
#else
# define X86_DATA_OFFSET4081
# ifdef __ILP32__
#  define X86_CODE_OFFSET4073
# else
#  define X86_CODE_OFFSET4077
# endif
#endif

.alignUNIX64_TRAMP_MAP_SIZE
.globltrampoline_code_table
FFI_HIDDEN(C(trampoline_code_table))

C(trampoline_code_table):
.reptUNIX64_TRAMP_MAP_SIZE / UNIX64_TRAMP_SIZE
_CET_ENDBR
subq$16, %rsp/* Make space on the stack */
movq%r10, (%rsp)/* Save %r10 on stack */
#ifdef __ILP32__
movlX86_DATA_OFFSET(%rip), %r10d/* Copy data into %r10 */
#else
movqX86_DATA_OFFSET(%rip), %r10/* Copy data into %r10 */
#endif
movq%r10, 8(%rsp)/* Save data on stack */
#ifdef __ILP32__
movlX86_CODE_OFFSET(%rip), %r10d/* Copy code into %r10 */
#else
movqX86_CODE_OFFSET(%rip), %r10/* Copy code into %r10 */
#endif
jmp*%r10/* Jump to code */
.align8
.endr
ENDF(C(trampoline_code_table))
.alignUNIX64_TRAMP_MAP_SIZE
#endif /* FFI_EXEC_STATIC_TRAMP */

所以秘密就是：code 和 data之间的偏移是固定的。因此，函数指针在被当作回调函数使用的同时，它同样也是回调函数数据的地址（加上偏移后）。在准备好回调函数和回调函数对应数据之后，程序通过jmp *%r10 跳转到其他的代码。

另外的问题是：这个偏移是怎么计算出来的？首先为了保持code 和 data之间固定的偏移，libffi 分配了两个连续的 4k(UNIX64_TRAMP_MAP_SIZE) 内存区域。所以偏移就是 4k减去从开始到现在所有指令长度的总和。假设我们在 Linux x86_64 上并且有endbr64 支持，我们可以这样计算X86_DATA_OFFSET：

1
2
3
4

X86_DATA_OFFSET
= 4096 - sizeof(`endbr64`) - sizeof(`subq $16, %rsp`) - sizeof(`movq %r10, (%rsp)`) - sizeof(`movq X86_DATA_OFFSET(%rip), %r10`)
= 4096 - 4 - 4 - 4 - 7
= 4077

其中4077就是上面代码中定义的偏移。

更多细节

另外有意思的事情是 libffi 怎么找到trampoline 表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

static int
ffi_tramp_get_libffi (void)
{
  FILE *fp;
  char file[PATH_MAX], line[PATH_MAX+100], perm[10], dev[10];
  unsigned long start, end, offset, inode;
  uintptr_t addr = (uintptr_t) tramp_globals.text;
  int nfields, found;

  snprintf (file, PATH_MAX, "/proc/%d/maps", getpid());
  fp = fopen (file, "r");
  if (fp == NULL)
    return 0;

  found = 0;
  while (feof (fp) == 0) {
    if (fgets (line, sizeof (line), fp) == 0)
      break;

    nfields = sscanf (line, "%lx-%lx %9s %lx %9s %ld %s",
      &start, &end, perm, &offset, dev, &inode, file);
    if (nfields != 7)
      continue;

    if (addr >= start && addr < end) {
      tramp_globals.offset = offset + (addr - start);
      found = 1;
      break;
    }
  }
  fclose (fp);

  if (!found)
    return 0;

  tramp_globals.fd = open (file, O_RDONLY);
  if (tramp_globals.fd == -1)
    return 0;

  /*
   * Allocate a trampoline table just to make sure that the trampoline code
   * table can be mapped.
   */
  if (!tramp_table_alloc ())
    {
      close (tramp_globals.fd);
      tramp_globals.fd = -1;
      return 0;
    }
  return 1;
}

libffi 读取了所有它自己的内存映射，定位了 text内存并且计算了 trampoline 表的偏移。注意tramp_globals.text 等于&trampoline_code_table。 然后，libffi 通过mmap 来映射 trampoline 表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

static int
tramp_table_map (struct tramp_table *table)
{
  char *addr;

  /*
   * Create an anonymous mapping twice the map size. The top half will be used
   * for the code table. The bottom half will be used for the parameter table.
   */
  addr = mmap (NULL, tramp_globals.map_size * 2, PROT_READ | PROT_WRITE,
    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

  if (addr == MAP_FAILED)
    return 0;

  /*
   * Replace the top half of the anonymous mapping with the code table mapping.
   */
  table->code_table = mmap (addr, tramp_globals.map_size, PROT_READ | PROT_EXEC,
    MAP_PRIVATE | MAP_FIXED, tramp_globals.fd, tramp_globals.offset);

  if (table->code_table == MAP_FAILED)
    {
      (void) munmap (addr, tramp_globals.map_size * 2);
      return 0;
    }
  table->parm_table = table->code_table + tramp_globals.map_size;
  return 1;
}

注意 trampoline 的代码在上述汇编代码里通过.rept 重复了多次来填满 4k 的内存。

总结

用一张图总结 libffi 怎么把闭包变成函数指针。

更新（2021.08.01）：这里 trampoline机制实际上避免了分配可写+可执行权限的内存因为上述tramp->code 的内容是在编译期生成的。

我的实现

为了检查我的理解是否正确，我也写了一个 demo。链接在这里。

其中核心库不足100行，相比 libffi来说应该很好理解。如果觉得有用的话可以给个 star。

对于分析 IOT 的安全工程师来说，模拟调试一个非本机架构的 binary/rootfs是很常见的需求，今天介绍一种我本人觉得虽然稍微有点扭曲但是效果最好的办法：用qemu-system 模拟运行异构的 Debian，并且相比常见的 network install的方法有很大的改进。

本文主要介绍用 qemu-system-arm 来安装运行 arm Debian，对于 mipsDebian 步骤基本是一样的。

For English version of this post, see here.

原理

以前的安装方法主要是通过 netboot 的 kernel 和 initrd 启动installer，然后再通过 network install 安装系统，最后把新的 kernel 和initrd 抽出来跑。总体上是可行的，但是问题是 QEMU本身模拟异构的系统的时候性能就慢一些，再加上模拟网卡的性能较差，基本上没个几个小时是不可能装完的。考虑到这一点，一个更好的办法应该是把offline installer跑起来，但是目前还没有见到有类似的文章，经过简单的改进和一些探索，我成功的实现了offline install，把安装时间基本缩短到 30 分钟左右。

准备

环境准备

我用的是 KUbuntu 20.04，理论上直接安装 qemu 即可。

1

apt install qemu-system qemu-utils bridge-utils libguestfs-tools

此外只需要下载 Debian 的 DVD 即可，以我用的 iso 为例。

1

wget -c "https://mirrors.ustc.edu.cn/debian-cd/10.6.0/armhf/iso-dvd/debian-10.6.0-armhf-DVD-1.iso"

制作系统盘

制作一个空白的系统盘镜像。

1

qemu-img create -f qcow2 debian.qcow2 8G

安装

抽取 kernel 和 initrd

qemu-system 跑 Linux 需要 kernel 和 initrd，这部分其实就是 grub的工作，因此如果想把 installer 跑起来，我们直接看看 installer 的 grub怎么写的。

1
2
3

mkdir mnt
sudo mount -o loop debian-10.6.0-armhf-DVD-1.iso ./mnt
cat mnt/boot/grub/grub.cfg

可以看到正常启动 installer 的选项。

1
2
3
4
5

menuentry 'Install' {
    set background_color=black
    linux    /install.ahf/vmlinuz  --- quiet
    initrd   /install.ahf/initrd.gz
}

于是从上述位置取出 vmlinuz 和 initrd。

1
2

cp mnt/install.ahf/vmlinuz ./
cp mnt/install.ahf/initrd.gz ./

到这里准备工作就完成了。

光盘挂载

如果熟悉 Debian Installer 的工作方式的话我们知道 installer干的事情就是把 /cdrom 当做 apt 源然后apt install整个系统而已，因此接下来理论上我们只要把光盘交给 QEMU 然后带着 kernel 和initrd 跑起来就行了，但是有一个坑点是 qemu-system-arm 的-cdrom选项是不工作的，我不太清楚原因，可能也是驱动的问题。但是这里可以通过另一种方法绕过这个坑点：把cd 作为硬盘接入 QEMU，然后挂载到 /cdrom，实际上用 U盘安装的时候 installer会自动帮你做这件事，只不过我们等会儿需要手动做一下。

网络驱动

另外一个坑点是 qemu-system-arm 并不支持 PCI网卡，从一些说法中我看到似乎是 arm Debian 不支持，总之如果要给 armDebian 分配网卡的话需要用 -netdev 和 -device来指定 virtio-blk-device，但是注意 -nic 的model 选项不能指定。

此外如果要以 tap模式分配主机网卡，还需要手动操作一下，以我的机器为例。

1
2
3
4
5
6
7
8
9
10
11

brctl addbr br0
brctl addif br0 ens33 # ens33 是物理网卡对应的接口
brctl addif br0 vmnic0
ip tuntap add dev vmnic0 mode tap
ip link set vmnic0 up
ip link set br0 up
ip addr add dev br0 192.168.4.158/24 # 和 ens33 同一网段
systemd-resolve --interface=br0 --set-dns=192.168.4.1 # 添加 DNS
ip ro del default
ip ro add default via 192.168.4.1 dev br0
echo 1 > /proc/sys/net/ipv4/ip_forward

安装系统

最后完整的 qemu-system 命令如下，注意如果用了 tap 网卡需要以 root身份执行。

1
2
3
4
5

sudo qemu-system-arm -machine virt -cpu cortex-a15 -smp cpus=4,maxcpus=4 -nographic \
        -kernel ./vmlinuz -initrd ./initrd.gz -m 1024 \
        -netdev user,id=n0 -device virtio-net-device,netdev=n0 \
        -drive file=debian.qcow2,if=none,format=qcow2,id=hd0 -device virtio-blk-device,drive=hd0 \
        -drive file=debian-10.6.0-armhf-DVD-1.iso,if=none,format=raw,id=hd1 -device virtio-blk-device,drive=hd1

这里注意我们把 debian-10.6.0-armhf-DVD-1.iso 是作为 hdd挂载的，因此首先就会遇到找不到 cdrom 的报错。

这里连续选择 No，然后会回到主菜单。

这里选择 Execute a shell 就可以进入 busybox了。当然本来是可以用 Alt + F2 来切换 Shell 的，但是在nographics 下我试了下没法发送 Alt所以只能这样了。

然后直接利用 dmesg 查看硬盘挂载的情况，以我的为例。

1
2
3
4

[    9.713510] virtio_blk virtio0: [vda] 9117960 512-byte logical blocks (4.67 GB/4.35 GiB)
[    9.741109]  vda: vda1 vda2
[    9.755204] virtio_blk virtio1: [vdb] 16777216 512-byte logical blocks (8.59 GB/8.00 GiB)
[    9.764864]  vdb: vdb1 vdb2 vdb3 < vdb5 >

这里显然可以看出来 /dev/vda 就是 iso 了，因此/dev/vda1 就是安装分区，我们只要把它挂载到/cdrom 就行了。

1
2

modprobe isofs
mount /dev/vda1 /cdrom

接下来返回主菜单选择 Detect and mount CD-ROM即可继续安装，剩下流程和正常 Debian 的安装基本完全一致。

但是最后安装 Grub 的时候会提示错误导致无法安装 grub。

不过这也无所谓，因为 grub 的工作会由 qemu-system 来完成。

启动

抽取新 kernel, initrd

接下来我们要启动 Debian 了，因此之前的 kernel 和 initrd已经不能使用了，所以我们需要从既有的磁盘镜像里抽取。

这里用到的工具是 virt-ls 和virt-copy-out，注意需要 root 权限。

1

sudo virt-ls -l debian.qcow2 /boot

可以看到 vmlinuz 和 initrd 的符号链接。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

drwxr-xr-x  3 0 0     1024 Nov 12 11:55 .
drwxr-xr-x 18 0 0     4096 Nov 12 11:19 ..
-rw-r--r--  1 0 0  3212152 Sep 17 21:42 System.map-4.19.0-11-armmp-lpae
-rw-r--r--  1 0 0  3212349 Oct 18 08:43 System.map-4.19.0-12-armmp-lpae
-rw-r--r--  1 0 0   210638 Sep 17 21:42 config-4.19.0-11-armmp-lpae
-rw-r--r--  1 0 0   210638 Oct 18 08:43 config-4.19.0-12-armmp-lpae
lrwxrwxrwx  1 0 0       31 Nov 12 11:51 initrd.img -> initrd.img-4.19.0-12-armmp-lpae
-rw-r--r--  1 0 0 20587326 Nov 12 11:33 initrd.img-4.19.0-11-armmp-lpae
-rw-r--r--  1 0 0 20590187 Nov 12 11:55 initrd.img-4.19.0-12-armmp-lpae
lrwxrwxrwx  1 0 0       31 Nov 12 11:24 initrd.img.old -> initrd.img-4.19.0-11-armmp-lpae
drwx------  2 0 0    12288 Nov 12 11:02 lost+found
lrwxrwxrwx  1 0 0       28 Nov 12 11:51 vmlinuz -> vmlinuz-4.19.0-12-armmp-lpae
-rw-r--r--  1 0 0  4403712 Sep 17 21:42 vmlinuz-4.19.0-11-armmp-lpae
-rw-r--r--  1 0 0  4403712 Oct 18 08:43 vmlinuz-4.19.0-12-armmp-lpae
lrwxrwxrwx  1 0 0       28 Nov 12 11:24 vmlinuz.old -> vmlinuz-4.19.0-11-armmp-lpae

然后把 vmlinuz 和 initrd 拷贝出来。

1
2

sudo virt-copy-out -a debian.qcow2 /boot/initrd.img-4.19.0-12-armmp-lpae ./
sudo virt-copy-out -a debian.qcow2 /boot/vmlinuz-4.19.0-12-armmp-lpae ./

启动

最后就是用新的 kernel 和 initrd 启动系统了。

1
2
3
4

sudo qemu-system-arm -machine virt -cpu cortex-a15 -smp cpus=4,maxcpus=4 -nographic --append "root=/dev/vda2" \
        -kernel ./vmlinuz-4.19.0-12-armmp-lpae -initrd ./initrd.img-4.19.0-12-armmp-lpae -m 1024 \
        -netdev tap,ifname=vmnic1,id=n0,script=no,downscript=no -device virtio-net-device,netdev=n0 \
        -drive file=debian.qcow2,if=none,format=qcow2,id=hd0 -device virtio-blk-device,drive=hd0

到这里就完美搞定了。

总结

当然除了 qemu-system 的方法以外还可以选择 qemu-usermode，但是qemu-usermode 有很多问题，比如不支持多线程调试，相对来说 qemu-system要灵活的多，可以自定义硬件，甚至可以直接在模拟的 Debian中调试。另外利用本文中的安装方法，在断网的情况下基本 30-60 min就可以安装完毕，比以往的 network install 快很多。

一些小细节：

• 对于链接的 libc 不是 glibc 的程序，最新的 openwrt 19 使用的musl，旧一点的 openwrt 15 用的 uclibc，基本够用。
• arm64 的 Debian/Ubuntu 不能直接运行部分 arm binary。
• 实机也是一个选择，比如树莓派是arm架构，很多路由器是mips架构。

参考

本文参考了非常多的文章，这里列出几篇主要的。

• 构建嵌入式qemu.md
• 在X86Linux下透過Qemu安裝ARM的Debian系統
• InstallingDebian on QEMU’s 32-bit ARM “virt” board

分析一个实模式二进制文件，比如 DOS 可执行文件或者 MBR代码从来不是一个简单的任务。目前最好的办法是先用 Bochs, QEMU 或者 Dosbox模拟运行，然后再使用 gdb, debug.exe 或者 IDAPro来远程调试。但是这都是在没有麒麟框架(QilingFramework)的情况下。现在我们想骄傲的宣布，麒麟框架正式支持 16bit二进制的模拟运行，并且与之伴随的还有麒麟框架多维度分析二进制文件的能力。

本文在介绍实模式模拟实现细节的同时也会作为一篇教程来介绍麒麟框架的使用。

For English version, see here.

Unicorn

麒麟框架基于 Unicorn 引擎，所以在介绍麒麟之前，我想先介绍一下 Unicorn引擎。Unicorn 是一个以 QEMU 部分代码为基础实现的一个纯粹的 CPU模拟器。与 QEMU 相比，Unicorn 有很多亮眼的特点：

• 平台独立。
• 易于使用和理解的 API。
• 动态 hook。
• 编译更快。:D

但是正如之前所说，Unicorn是一个纯粹的CPU模拟器，它不知道自己上层运行的操作系统是什么，所以这里就有了麒麟框架。

麒麟

有时候，我自己都不知道怎么解释麒麟到底是什么。 ---- LauKaijern，麒麟的作者

确实，很难用一句话来定义麒麟。为了更全面的描述麒麟，我想从麒麟四个核心功能来说明：模拟、分析、调试、扩展。

模拟

麒麟最基础的功能就是模拟，但是和 Unicorn的模拟有所不同。刚才提到过，Unicorn 是一个 CPU模拟器，而麒麟实际上是一个操作系统模拟器。下面是一个简单的图来说明一个原生应用和一个模拟应用的联系。

1
2
3
4
5
6
7

|-------|           |---------|
|Program| <-------> | Binary  |
|  OS   | <-------> | Qiling  |
|  CPU  | <-------> | Unicorn |
|-------|           |---------|

原生应用              模拟应用

通常来说，原生应用在一个特定的操作系统环境上运行，这个操作系统会提供各种各样的API，而操作系统运行在一个 CPU之上。对于一个用麒麟模拟的应用，架构是非常相似的：Unicorn 扮演了 CPU模拟器的角色，麒麟来完成操作系统的任务执行目标二进制文件。为了实现这些，麒麟分为了三层。

1
2
3
4
5

|--------|  ---
|   os   |   |
| loader | Qiling
|  arch  |   |
|--------|  ---

• arch 层进行一些和 CPU架构相关的设置，比如大小端，寄存器等等。
• loader层像真正的系统二进制加载器一样，解析目标二进制文件，设置内存布局，把代码和数据加载到内存里。
• os 层是最重要的部分，提供了系统调用的实现。

HI.COM 例子

接下来用 DOS 和 HI.COM作为例子来讲解这三层是如何相互配合来模拟操作系统的。

对于 arch 层，我们可以假设 CPU 是8086，它设置起来比较简单，只需要设置好寄存器即可。

COM 文件就只是一个内存镜像，没有任何文件头。因此 loader层的实现极其简单：分配足够的内存，把整个文件写入到内存，设置好 PC和栈即可。

对于 os 层，麒麟要做的事情就是尽可能多的实现中断。下面是HI.COM 的源代码：

1
2
3
4
5
6
7

mov ah,9
mov dx, 10d
int 21
mov ax, 4c00
int 21
nop
db "Hello world!$"

当 Unicorn 执行到 INT 21的时候，它并不知道这个中断的具体含义，因此它会调用我们在 os层中定义的 hook 函数，下面就是 os 层相应的实现：

1
2
3
4
5
6
7
8
9

def int21(self): # Handler for INT 21
    ah = self.ql.reg.ah
    if ah == 0x4C:
        self.ql.uc.emu_stop() # Stop emulation
    # other interrupts...
    elif ah == 0x9:
        s = self.read_dos_string_from_ds_dx() # Read string
        self.ql.nprint(s) # Print the string to console
    # other interrupts...

这就是麒麟为了模拟 COM执行文件所有的工作。其实还是蛮简单的，不是吗？

Petya 例子

实际上，为了模拟一个 16bit二进制文件，我大多数的工作都是合理的实现中断。比如 Petya 是一个 MBR病毒，它大量的使用了 BIOS 提供的 INT 10图像服务。在现代终端上一个对应的实现是 curses所以我花了很多时间来把过去的图像中断翻译成了 curses的调用。以 INT10, 0 为例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

def int10(self):
    # BIOS video support
    # https://en.wikipedia.org/wiki/INT_10H
    # https://stanislavs.org/helppc/idx_interrupt.html
    # implemented by curses
    ah = self.ql.reg.ah
    al = self.ql.reg.al
    if ah==0:
        # time to set up curses
        # copied from curses.wrapper
        self.stdscr = curses.initscr()
        curses.noecho()
        curses.cbreak()
        self.stdscr.keypad(1)
        try:
            curses.start_color()
        except:
            pass
        if al == 0 or al == 1:
            curses.resizeterm(25, 40)
        elif al == 2 or al == 3:
            curses.resizeterm(25, 80)
        elif al == 4 or al == 5 or al == 9 or al == 0xD or al == 0x13:
            curses.resizeterm(200, 320)
        elif al == 6:
            curses.resizeterm(200, 640)
        elif al == 8:
            curses.resizeterm(200, 160)
        elif al == 0xA or al == 0xE:
            curses.resizeterm(200, 640)
        elif al == 0xF:
            curses.resizeterm(350, 640)
        elif al == 0x10:
            curses.resizeterm(350, 640)
        elif al == 0x11 or al == 0x12:
            curses.resizeterm(480, 640)
        else:
            self.ql.nprint("Exception: int 10h syscall Not Found, al: %s" % hex(al))
            raise NotImplementedError()
        # Quoted from https://linux.die.net/man/3/resizeterm
        #
        # If ncurses is configured to supply its own SIGWINCH handler, 
        # the resizeterm function ungetch's a KEY_RESIZE which will be 
        # read on the next call to getch.
        ch = self._get_ch_non_blocking()
        if ch == curses.KEY_RESIZE:
            self.ql.nprint(f"[!] You term has been resized!")
        elif ch != -1:
            curses.ungetch(ch)
        self.stdscr.scrollok(True)
            
        if not curses.has_colors():
            self.ql.nprint(f"[!] Warning: your terminal doesn't support colors, content might not be displayed correctly.")
        
        # https://en.wikipedia.org/wiki/BIOS_color_attributes
        # blink support?
        if curses.has_colors():
            for fg in range(16):
                for bg in range(16):
                    color_pair_index = 16*fg + bg + 1
                    if fg not in self.color_pairs:
                        self.color_pairs[fg] = {}
                    curses.init_pair(color_pair_index, COLORS_MAPPING[fg], COLORS_MAPPING[bg])
                    color_pair = curses.color_pair(color_pair_index)
                    self.color_pairs[fg][bg] = color_pair
                    self.revese_color_pairs[color_pair] = (fg, bg)

英文有句名言是 "Simple isbetter"。现在，相比以前的屏幕，终端已经变得越来越复杂了，结果实现一个简单的屏幕反而变得更难了，因为有太多的corner cases。

模拟侧重点的区别

有心的读者可能已经注意到了，我们这里的模拟其实和真正的 DOS系统行为并不完全一样。没错，麒麟的模拟就是这样的。完美和快速的模拟从来不是麒麟的首要目标。麒麟关注的是为用户在二进制分析时提供最大的便利。我马上会谈到这一点。

顺带一提，麒麟从设计之初就是平台独立的。这意味着用户可以在 Windows上运行一个 Linux ELF，在 Mac OS 上运行一个 Windows exe。然而对于 QEMU来说这是不可能的，因为它需要把系统调用转发到主机上。

分析

麒麟远远不止是一个模拟器。它同样提供了大量的API。

fs_mapper

让我们以 fs_mapper 为例（因为我刚重构过 XD）：

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

#!/usr/bin/env python3
# Source: https://github.com/qilingframework/qiling/blob/dev/examples/hello_x86_linux_fake_urandom.py
# 
# Cross Platform and Multi Architecture Advanced Binary Emulation Framework
# Built on top of Unicorn emulator (www.unicorn-engine.org) 

from qiling import *
from qiling.os.mapper import QlFsMappedObject

class Fake_urandom(QlFsMappedObject):

    def read(self, size):
        return b"\x01" # fixed value for reading /dev/urandom

    def fstat(self): # syscall fstat will ignore it if return -1
        return -1

    def close(self):
        return 0

if __name__ == "__main__":
    ql = Qiling(["rootfs/x86_linux/bin/x86_fetch_urandom"], "rootfs/x86_linux")
    ql.add_fs_mapper("/dev/urandom", Fake_urandom())
    ql.run()

目标二进制文件 x86_fetch_urandom 的源代码为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Souce: https://github.com/qilingframework/qiling/blob/dev/examples/src/linux/fetch_urandom.c
#include <stdio.h>

int main(void) {
    FILE *fp;
    int randno; 

    if ((fp = fopen("/dev/urandom", "r")) == NULL) {
    fprintf(stderr, "Error! Could not open /dev/urandom for read\n");
    return -1;
    }

    randno = fgetc(fp);
    printf("randno: %d\n", randno);
    fclose(fp);

    return 0;
}

这个二进制文件就简单的从 Linux 系统下的伪随机字节流/dev/urandom 获取一个字节。然而，如果使用了ql.add_fs_mapper("/dev/urandom", Fake_urandom())我们就可以劫持这次读取过程并且返回一个固定的字节。

除了设备文件，fs_mapper还可以模拟一个完整的磁盘。下面是模拟 Petya 的代码：

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

#!/usr/bin/env python3
# Source: https://github.com/qilingframework/qiling/blob/dev/examples/petya_8086_mbr.py
# 
# Cross Platform and Multi Architecture Advanced Binary Emulation Framework
# Built on top of Unicorn emulator (www.unicorn-engine.org)

import sys
sys.path.append("..")
from qiling import *
from qiling.os.disk import QlDisk

if __name__ == "__main__":
    ql = Qiling(["rootfs/8086/petya/mbr.bin"], 
                 "rootfs/8086",
                 console=False, 
                 output="debug", 
                 log_dir=".")
    # Note:
    # This image is only intended for PoC since the core petya code resides in the
    # specific sectors of a harddisk. It doesn't contain any data, either encryted
    # or unencrypted.

    ql.add_fs_mapper(0x80, QlDisk("rootfs/8086/petya/out_1M.raw", 0x80))
    ql.run()

0x80 是实模式下磁盘的索引。对于 Linux 和Windows，这个值可以是 /dev/sda 或者\\.\PHYSICALDRIVE0。QlDisk是一个类，可以把一个文件模拟成磁盘，比如磁头、柱面和扇区的支持等等。之所以要模拟一个侧畔，是因为Petya 使用了 BIOS 提供的 INT 13磁盘服务来直接读写硬盘。为了实现这些中断，把一个文件映射成模拟环境下的磁盘是有必要的。

系统调用劫持

另一个例子是系统调用劫持。下面是文档里的一个例子。

1
2
3
4
5
6
7
8
9
10

from qiling import *

def my_puts(ql):
    addr = ql.os.function_arg[0]
    print("puts(%s)" % ql.mem.string(addr))

if __name__ == "__main__":
    ql = Qiling(["rootfs/x8664_linux/bin/x8664_hello"], "rootfs/x8664_linux", output="debug")
    ql.set_api('puts', my_puts)
    ql.run()

因为麒麟自己就是整个 OS环境，所以把系统调用暴露给用户是非常简单就可以实现的。

快照 & 部分执行

快照可以让用户保存或者恢复一个程序执行的上下文，包括 CPU寄存器，内存内容甚至是文件描述符。配合部分执行的API，快照可以让用户完全控制一个程序，随意的测试一个程序内的任何一段代码。下面是分析Petya 的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

def one_round(ql: Qiling, key: bytes, key_address):
    gkeys = generate_key(key)
    ql.mem.write(key_address, gkeys)
    # Partial executaion
    ql.run(begin=verfication_start_ip, end=verfication_start_ip+6)
    lba37 = ql.mem.read(ql.reg.sp + 0x220, 0x200)
    for ch in lba37:
        if ch != 0x37:
            return False
    return True

# In this stage, we will crack for the password.
def second_stage(ql: Qiling):
    disk = QlDisk("rootfs/8086/petya/out_1M.raw", 0x80)
    #nonce = get_nonce(disk)
    # Prepare stack
    verfication_data = disk.read_sectors(0x37, 1)
    nonce_data = disk.read_sectors(0x36, 1)
    ql.reg.sp -= 0x200
    verification_data_address = ql.reg.sp
    ql.reg.sp -= 0x200
    nonce_address = ql.reg.sp + 0x21
    ql.reg.sp -= 0x20
    key_address = ql.reg.sp
    ql.mem.write(verification_data_address, verfication_data)
    ql.mem.write(nonce_address - 0x21, nonce_data)
    ql.arch.stack_push(0x200)
    ql.arch.stack_push(verification_data_address)
    ql.arch.stack_push(0)
    ql.arch.stack_push(nonce_address)
    ql.arch.stack_push(key_address)
    for x in product(list(accepted_chars), repeat=2):
        ctx = ql.save()
        # 3xMxjxXxLxoxmxAx
        key = b"3xMxjxXxLxoxmx" + ("".join(x)).encode("utf-8")
        print(f"Trying: {key}")
        if one_round(ql, key, key_address):
            print(f"Key: {key}")
            return key
        else:
            ql.restore(ctx)
    return None

在上面的代码中，我们首先准备好了堆栈，然后保存了一次快照。之后我们把解密的key 写入到函数参数然后直接调用了验证函数。如果结果表明 key是错误的，那么我们直接恢复之前保存的快照然后再次尝试。

限于篇幅，我无法在这里介绍麒麟所有的功能。如果有兴趣可以参考麒麟的文档。总而言之，正是这些强大的API让麒麟成为了一个真正的动态打桩分析框架，让麒麟区别于其他的模拟器。

调试

我们知道，QEMU 是支持 gdb 远程调试的，那么麒麟怎么能不支持这么好的feature 呢？

在写下这篇文章的时候，麒麟的调试功能仍然在紧张开发中，但是 16bit调试已经完成了。简单的增加一行 ql.debugger=True 然后连接gdb 到 127.0.0.1:9999 即可，下面是一张截图。

扩展

目前，麒麟正在把一些逻辑解耦成为单独的扩展。其中我们最近的一个工作是IDA插件，下面是相应的截图：

哦，等一下，我知道大家都是命令行高手，这样的插件真的有意义吗？

当然，正是有了 IDA 插件，至少你不需要再买一份 IDA Linux授权，因为你可以在 Windows/Mac OS 上运行 Linux ELF，不是吗？

在麒麟的 qiling/extensionsdirectory 目录下还有很多有意思的插件，有兴趣可以查看相应的 REAME或者文档。

总结

麒麟框架是一个非常有野心的框架。我们的终极目标是写出一个像瑞士军刀一样的分析框架，解除各种限制，比如因为平台或者系统不同导致的壁垒，为广大的逆向工程师们提供最好的体验。没有什么能阻止我们进一步的二进制分析！

然而，麒麟框架现在仍然不完美。欢迎大家给我们一个 star以示鼓励并且加入到我们的开发中来！我们期待合并你的第一个 PR！

项目地址为：https://github.com/qilingframework/qiling

后记

• Qiling 确实是一个拼写错误。本来应该是Qilin 的。不过无所谓啦 :P
• 实际上，暴力穷举破解 Petya 的 key是没法在可接受的时间内完成的。这里我们仅仅是展示麒麟的 API。
• IDA 7.0 不支持 Python3，但是 Ghidra 支持马上就会有了。
• TLDR：点个 star 再走吧。

TCTF2020 的 flash 题目。

题目本体见这里。

一开始看到名字我还以为是 Adobe 那个 flash 逆向，结果下载下来一看run.sh：

1
2
3
4

#! /bin/sh


qemu-system-mips -M mips -bios ./flash -nographic -m 16M -monitor /dev/null 2>/dev/null

哦，得嘞，原来是闪存那个 flash。

题目的关键当然是这个 flash 文件了，一开始我总以为它是 qemu的镜像文件，但是无奈用了各种工具检查都显示是纯数据文件，最后我终于注意到了-bios参数，实际上意思就是从这个文件第一行开始执行，所以直接拖进IDA就可以了。

环境配置

首先是安装 qemu-system-mips，直接apt install qemu-system-mips 即可。

然后为了能够调试这个文件，我们需要目标架构包含 mips 的gdb，通常情况下预编译的 gdb 是只有 i386 和 x86_64的，所以我们还需要手动编译一下，这里我选择的是 gdb9.2。

1
2
3
4
5
6

wget -c "http://ftp.gnu.org/gnu/gdb/gdb-9.2.tar.gz"
tar xf gdb-9.2.tar.gz
cd gdb-9.2
mkdir build
./configure --target=mips --with-python=/usr/bin/python3
make -j8

这里选定了 Python 路径是因为我需要用到 pwndbg。

编译完成后注意在运行的时候需要指定 data-directory。

1
2

cd gdb
./gdb --data-directory ./data-directory/

然后输入 set architecture 再按 tab 就可以看到包含了各种mips 的架构。

1
2
3
4
5
6
7
8
9
10
11
12

pwndbg> set architecture 
auto                 mips:4010            mips:5500            mips:isa32           mips:loongson_2e
mips                 mips:4100            mips:5900            mips:isa32r2         mips:loongson_2f
mips:10000           mips:4111            mips:6000            mips:isa32r3         mips:micromips
mips:12000           mips:4120            mips:7000            mips:isa32r5         mips:mips5
mips:14000           mips:4300            mips:8000            mips:isa32r6         mips:octeon
mips:16              mips:4400            mips:9000            mips:isa64           mips:octeon+
mips:16000           mips:4600            mips:gs264e          mips:isa64r2         mips:octeon2
mips:3000            mips:4650            mips:gs464           mips:isa64r3         mips:octeon3
mips:3900            mips:5000            mips:gs464e          mips:isa64r5         mips:sb1
mips:4000            mips:5400            mips:interaptiv-mr2  mips:isa64r6         mips:xlr
pwndbg> set architecture 

最后在 run.sh 加一个-s，这样在程序启动的时候就会连带启动 gdbserver了，接下来只需要在 gdb 里连接即可。

1

pwndbg> target remote 127.0.0.1:1234

到这里环境配置就完成了。

内存布局

首先第一个难点是拖进IDA后我们并不知道内存布局，但是从第一行代码可以猜测基址是0xFC00000。

1
2
3

ROM:0FC00000                 .text # ROM
ROM:0FC00000                 j       loc_FC01680
ROM:0FC00004                 nop

IDA rebase之后跟随跳转可以看到这样一行。

1

li      $t0, 0xBFC01550

因此大胆猜测实际基址是 0xBFC00000，设置之后可以看到 IDA左侧多了很多函数，所以这个基址应该是正确的。

接着继续跟随逻辑可以看到这样一个关键函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

ROM:BFC015E4 sub_BFC015E4:                            # CODE XREF: sub_BFC00000+16C0↓p
ROM:BFC015E4
ROM:BFC015E4 var_18          = -0x18
ROM:BFC015E4 addr80000000    = -0x14
ROM:BFC015E4 var_10          = -0x10
ROM:BFC015E4 var_8           = -8
ROM:BFC015E4 var_4           = -4
ROM:BFC015E4
ROM:BFC015E4                 addiu   $sp, -0x28
ROM:BFC015E8                 sw      $ra, 0x28+var_4($sp)
ROM:BFC015EC                 sw      $fp, 0x28+var_8($sp)
ROM:BFC015F0                 move    $fp, $sp
ROM:BFC015F4                 lui     $v0, 0xBFC1
ROM:BFC015F8                 sw      $v0, 0x28+var_18($fp)
ROM:BFC015FC                 lui     $v0, 0x8000
ROM:BFC01600                 sw      $v0, 0x28+addr80000000($fp)
ROM:BFC01604                 sw      $zero, 0x28+var_10($fp)
ROM:BFC01608                 b       loc_BFC0163C
ROM:BFC0160C                 nop
ROM:BFC01610  # ---------------------------------------------------------------------------
ROM:BFC01610
ROM:BFC01610 loc_BFC01610:                            # CODE XREF: sub_BFC015E4+60↓j
ROM:BFC01610                 lw      $v1, 0x28+var_18($fp)
ROM:BFC01614                 addiu   $v0, $v1, 4
ROM:BFC01618                 sw      $v0, 0x28+var_18($fp)
ROM:BFC0161C                 lw      $v0, 0x28+addr80000000($fp)
ROM:BFC01620                 addiu   $a0, $v0, 4
ROM:BFC01624                 sw      $a0, 0x28+addr80000000($fp)
ROM:BFC01628                 lw      $v1, 0($v1)
ROM:BFC0162C                 sw      $v1, 0($v0)
ROM:BFC01630                 lw      $v0, 0x28+var_10($fp)
ROM:BFC01634                 addiu   $v0, 1
ROM:BFC01638                 sw      $v0, 0x28+var_10($fp)
ROM:BFC0163C
ROM:BFC0163C loc_BFC0163C:                            # CODE XREF: sub_BFC015E4+24↑j
ROM:BFC0163C                 lw      $v0, 0x28+var_10($fp)
ROM:BFC01640                 slti    $v0, 0x1000
ROM:BFC01644                 bnez    $v0, loc_BFC01610
ROM:BFC01648                 nop
ROM:BFC0164C                 li      $v0, 0x80000500
ROM:BFC01654                 jalr    $v0
ROM:BFC01658                 nop
ROM:BFC0165C                 nop
ROM:BFC01660                 move    $sp, $fp
ROM:BFC01664                 lw      $ra, 0x28+var_4($sp)
ROM:BFC01668                 lw      $fp, 0x28+var_8($sp)
ROM:BFC0166C                 addiu   $sp, 0x28
ROM:BFC01670                 jr      $ra
ROM:BFC01674                 nop
ROM:BFC01674  # End of function sub_BFC015E4

刚才说过，这个 flash 文件是作为 bios运行的，因此这里需要先把用户态的代码加载到指定位置。不难看出这里是把0xBFC10000 - 0xBFC14000 这 0x4000 字节的代码加载到了 0x80000000的位置然后跳转到 0x80000500开始执行，因此接下来我选择把原文件拆成两份分别加载到 IDA 中。

到这里文件的大致内存布局就非常清晰了。

中断

跳转到 0x80000500 后第一件事是设置了 Compare 和 Count 寄存器。

1
2
3
4
5
6
7

ROM:80000564 sub_80000564:                            # CODE XREF: ROM:80000500↑p
ROM:80000564                                          # ROM:80002668↓p
ROM:80000564                 li      $t0, 0x1000
ROM:80000568                 mtc0    $t0, Compare     # Timer Compare
ROM:8000056C                 mtc0    $zero, Count     # Timer Count
ROM:80000570                 jr      $ra
ROM:80000574                 nop

这里根据 google，mips 处理器会不断增加 Count 寄存器的计数，当 Count等于 Compare 的时候会触发一个中断。

接下来程序在加载了 Welcome 字符串后就原地死循环了。

1
2
3
4
5
6
7
8
9
10
11

ROM:80000D34 loc_80000D34:                            # CODE XREF: ROM:80000518↑j
ROM:80000D34                 addiu   $sp, -0x20
ROM:80000D38                 sw      $ra, 0x1C($sp)
ROM:80000D3C                 sw      $fp, 0x18($sp)
ROM:80000D40                 move    $fp, $sp
ROM:80000D44                 lui     $v0, 0x8000
ROM:80000D48                 addiu   $a0, $v0, (aWelcomeToFlagM - 0x80000000)  # "Welcome to Flag Machine"
ROM:80000D4C                 mtc0    $zero, Count     # Timer Count
ROM:80000D50
ROM:80000D50 loc_80000D50:                            # CODE XREF: ROM:loc_80000D50↓j
ROM:80000D50                 b       loc_80000D50

这里就非常有意思了，程序的控制流进入了死循环，但是我们明明看到字符串被正常输出了出来，是怎么办到的呢？我一开始也完全不理解，后来联想到上面的Count 和 Compare寄存器我突然有了答案：是通过中断的方式来改变控制流。

那另一个问题就来了，根据 x86的知识，应该有一张中断表来保存不同中断子程序的入口，那么 mips上中断子程序的入口在哪呢？经过我一阵 google 后，我终于找到了原来 mips的中断处理入口固定为 0x80000180，用 IDA 定义函数一看：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

ROM:80000180 interrupt:
ROM:80000180
ROM:80000180 arg_0           =  0
ROM:80000180 arg_4           =  4
ROM:80000180 arg_8           =  8
ROM:80000180 arg_C           =  0xC
ROM:80000180 arg_10          =  0x10
ROM:80000180 arg_14          =  0x14
ROM:80000180 arg_18          =  0x18
ROM:80000180 arg_1C          =  0x1C
ROM:80000180 arg_20          =  0x20
ROM:80000180 arg_24          =  0x24
ROM:80000180 arg_28          =  0x28
ROM:80000180 arg_2C          =  0x2C
ROM:80000180 arg_30          =  0x30
ROM:80000180 arg_34          =  0x34
ROM:80000180 arg_38          =  0x38
ROM:80000180 arg_3C          =  0x3C
ROM:80000180 arg_40          =  0x40
ROM:80000180 arg_44          =  0x44
ROM:80000180 arg_48          =  0x48
ROM:80000180 arg_4C          =  0x4C
ROM:80000180 arg_50          =  0x50
ROM:80000180 arg_54          =  0x54
ROM:80000180 arg_58          =  0x58
ROM:80000180 arg_5C          =  0x5C
ROM:80000180 arg_60          =  0x60
ROM:80000180 arg_6C          =  0x6C
ROM:80000180 arg_70          =  0x70
ROM:80000180 arg_74          =  0x74
ROM:80000180 arg_78          =  0x78
ROM:80000180 arg_7C          =  0x7C
ROM:80000180 arg_80          =  0x80
ROM:80000180 arg_84          =  0x84
ROM:80000180
ROM:80000180                 move    $k1, $sp
ROM:80000184                 li      $sp, 0x8043FF6C
ROM:8000018C                 sw      $at, arg_0($sp)
ROM:80000190                 sw      $v0, arg_4($sp)
ROM:80000194                 sw      $v1, arg_8($sp)
ROM:80000198                 sw      $a0, arg_C($sp)
ROM:8000019C                 sw      $a1, arg_10($sp)
ROM:800001A0                 sw      $a2, arg_14($sp)
ROM:800001A4                 sw      $a3, arg_18($sp)
ROM:800001A8                 sw      $t0, arg_1C($sp)
ROM:800001AC                 sw      $t1, arg_20($sp)
ROM:800001B0                 sw      $t2, arg_24($sp)
ROM:800001B4                 sw      $t3, arg_28($sp)
ROM:800001B8                 sw      $t4, arg_2C($sp)
ROM:800001BC                 sw      $t5, arg_30($sp)
ROM:800001C0                 sw      $t6, arg_34($sp)
ROM:800001C4                 sw      $t7, arg_38($sp)
ROM:800001C8                 sw      $s0, arg_3C($sp)
ROM:800001CC                 sw      $s1, arg_40($sp)
ROM:800001D0                 sw      $s2, arg_44($sp)
ROM:800001D4                 sw      $s3, arg_48($sp)
ROM:800001D8                 sw      $s4, arg_4C($sp)
ROM:800001DC                 sw      $s5, arg_50($sp)
ROM:800001E0                 sw      $s6, arg_54($sp)
ROM:800001E4                 sw      $s7, arg_58($sp)
ROM:800001E8                 sw      $t8, arg_5C($sp)
ROM:800001EC                 sw      $t9, arg_60($sp)
ROM:800001F0                 sw      $gp, arg_6C($sp)
ROM:800001F4                 sw      $k1, arg_70($sp)
ROM:800001F8                 sw      $fp, arg_74($sp)
ROM:800001FC                 sw      $ra, arg_78($sp)
ROM:80000200                 mfc0    $t0, EPC         # Exception Program Counter
ROM:80000204                 sw      $t0, arg_7C($sp)
ROM:80000208                 mfc0    $t0, ErrorEPC    # Error Exception Program Counter
ROM:8000020C                 sw      $t0, arg_80($sp)
ROM:80000210                 mfc0    $t0, SR          # Status register
ROM:80000214                 sw      $t0, arg_84($sp)
ROM:80000218                 addi    $a0, $sp, 0
ROM:8000021C                 lw      $k0, off_80003D20
ROM:80000224                 jalr    $k0
ROM:80000228                 nop
ROM:8000022C                 nop
ROM:80000230                 lw      $t0, arg_7C($sp)
ROM:80000234                 mtc0    $t0, EPC         # Exception Program Counter
ROM:80000238                 lw      $t0, arg_80($sp)
ROM:8000023C                 mtc0    $t0, ErrorEPC    # Error Exception Program Counter
ROM:80000240                 lw      $t0, arg_84($sp)
ROM:80000244                 mtc0    $t0, SR          # Status register
ROM:80000248                 lw      $v0, arg_4($sp)
ROM:8000024C                 lw      $v1, arg_8($sp)
ROM:80000250                 lw      $a0, arg_C($sp)
ROM:80000254                 lw      $a1, arg_10($sp)
ROM:80000258                 lw      $a2, arg_14($sp)
ROM:8000025C                 lw      $a3, arg_18($sp)
ROM:80000260                 lw      $t0, arg_1C($sp)
ROM:80000264                 lw      $t1, arg_20($sp)
ROM:80000268                 lw      $t2, arg_24($sp)
ROM:8000026C                 lw      $t3, arg_28($sp)
ROM:80000270                 lw      $t4, arg_2C($sp)
ROM:80000274                 lw      $t5, arg_30($sp)
ROM:80000278                 lw      $t6, arg_34($sp)
ROM:8000027C                 lw      $t7, arg_38($sp)
ROM:80000280                 lw      $s0, arg_3C($sp)
ROM:80000284                 lw      $s1, arg_40($sp)
ROM:80000288                 lw      $s2, arg_44($sp)
ROM:8000028C                 lw      $s3, arg_48($sp)
ROM:80000290                 lw      $s4, arg_4C($sp)
ROM:80000294                 lw      $s5, arg_50($sp)
ROM:80000298                 lw      $s6, arg_54($sp)
ROM:8000029C                 lw      $s7, arg_58($sp)
ROM:800002A0                 lw      $t8, arg_5C($sp)
ROM:800002A4                 lw      $t9, arg_60($sp)
ROM:800002A8                 lw      $gp, arg_6C($sp)
ROM:800002AC                 lw      $k1, arg_70($sp)
ROM:800002B0                 lw      $fp, arg_74($sp)
ROM:800002B4                 lw      $ra, arg_78($sp)
ROM:800002B8                 move    $sp, $k1
ROM:800002BC                 eret
ROM:800002BC  # End of function interrupt

先保存所有寄存器，再恢复所有寄存器，明显是中断子程序了。

到这里疑问其实只解决了一半，因为通常的中断在完成后回立即返回原来的上下文，也就是原来的位置，如果没有特殊处理的话中断之后仍然会回到死循环的位置，所以这里的中断子程序应该有一些特殊的处理。又是一番google，原来 mips 在发生中断的时候会把返回地址保存在 EPC中，而上面的中断子程序中 EPC的值是存在栈上的，也就是说只要修改了栈上的值，结束中断后返回的地址也会发生变化（其实就类似线程调度的底层实现）。想到这个地方基本上就可以说豁然开朗了，把断点分别设置在jalr $k0 前后，成功观察到 arg_7C($sp)值发生了变化，所以我们的推测应该是正确的，接下来就是把这里地址变换的逻辑逆出来了。

这里跟踪 jalr $k0，发现最后关键是调用了一个syscall又回到了内核态，继续跟踪可以看到逻辑还算比较清晰，在第一次进入的时候初始化地址映射，然后根据特定的算法计算映射后的地址。我没有太多的耐心逆向具体的算法，我选择直接把地址映射表dump 出来然后实现地址计算的方法，脚本如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

import struct

def pp(l):
    for i in l:
        print(hex(i))

addr2000 = [
    0x800287c0,  0x80028004,  0xbfc01550
]

addr2800 = []

bs = open("28000.dump", "rb+").read()

for i in range(len(bs)//4):
    addr2800.append(struct.unpack(">I", bs[4*i:4*(i+1)])[0])

#https://stackoverflow.com/questions/27506474/how-to-byte-swap-a-32-bit-integer-in-python
def swap32(i):
    return struct.unpack("<I", struct.pack(">I", i))[0]

addr = 0x80000610

x = 0xD3ABC0DE

epc_xor = addr ^ x

xored_list = [0x7EC5AB53, 0xFEE9AB53, 0x6EC5AB53, 0xEAE9AB53, 0x12C5AB53, 0x96E9AB53, 0x32C5AB53, 0x82E9AB53, 0xCEC6AB53, 0xAEE9AB53, 0xFEC6AB53, 0x5AE9AB53, 0xEEC6AB53, 0x46E9AB53, 0x96C6AB53, 0x72E9AB53, 0xBEC6AB53, 0x1EE9AB53, 0xAEC6AB53, 0x0AE9AB53, 0x4EC6AB53, 0x36E9AB53, 0x62C6AB53, 0x22E9AB53, 0x12C6AB53, 0xCEEAAB53, 0x3EC6AB53, 0xFAEAAB53, 0xDEC7AB53, 0xE6EAAB53, 0xE6C7AB53, 0x92EAAB53, 0x96C7AB53, 0xBEEAAB53, 0x52C7AB53, 0xAAEAAB53, 0x16C7AB53, 0x56EAAB53, 0xCAC8AB53, 0x42EAAB53, 0xEAC8AB53, 0x6EEAAB53, 0xA6C8AB53, 0x1AEAAB53, 0x46C8AB53, 0x06EAAB53, 0x7AC8AB53, 0x32EAAB53, 0x6AC8AB53, 0xDEEBAB53, 0x06C8AB53, 0xCAEBAB53, 0x3AC8AB53, 0xF6EBAB53, 0x2EC8AB53, 0xE2EBAB53, 0xDEC9AB53, 0x8EEBAB53, 0xFAC9AB53, 0xBAEBAB53, 0xEEC9AB53, 0xA6EBAB53, 0xE2C9AB53, 0x52EBAB53, 0x92C9AB53, 0x7EEBAB53, 0xA6C9AB53, 0x6AEBAB53, 0x5AC9AB53, 0x16EBAB53, 0x66C9AB53, 0x02EBAB53, 0x1AC9AB53, 0x2EEBAB53, 0x0EC9AB53, 0xDAECAB53, 0x3EC9AB53, 0xC6ECAB53, 0xD6CAAB53, 0xF2ECAB53, 0xCACAAB53, 0x9EECAB53, 0xFECAAB53, 0x8AECAB53, 0xEECAAB53, 0xB6ECAB53, 0x82CAAB53, 0xA2ECAB53, 0xB6CAAB53, 0x4EECAB53, 0x7ACAAB53, 0x7AECAB53, 0x66CAAB53, 0x66ECAB53, 0x2ACAAB53, 0x12ECAB53, 0xEECBAB53, 0x3EECAB53, 0x9ACBAB53, 0x2AECAB53, 0x5ECBAB53, 0xD6EDAB53, 0x7ECBAB53, 0xC2EDAB53, 0x16CBAB53, 0xEEEDAB53, 0xD2CCAB53, 0x9AEDAB53, 0xC6CCAB53, 0x86EDAB53, 0xEACCAB53, 0xB2EDAB53, 0x9ECCAB53, 0x5EEDAB53, 0x92CCAB53, 0x4AEDAB53, 0xBACCAB53, 0x76EDAB53, 0xAECCAB53, 0x62EDAB53, 0xA2CCAB53, 0x0EEDAB53, 0x4ECCAB53, 0x3AEDAB53, 0x7ACCAB53, 0x26EDAB53, 0x16CCAB53, 0xD2EEAB53, 0xF2CDAB53, 0xFEEEAB53, 0x8ECDAB53, 0xEAEEAB53, 0xBACDAB53, 0x96EEAB53, 0xAACDAB53, 0x82EEAB53, 0x52CDAB53, 0xAEEEAB53, 0x66CDAB53, 0x5AEEAB53, 0x1ACDAB53, 0x46EEAB53, 0x36CDAB53, 0x72EEAB53, 0xC6CEAB53, 0x1EEEAB53, 0x8ECEAB53, 0x0AEEAB53, 0x82CEAB53, 0x36EEAB53, 0xAECEAB53, 0x22EEAB53, 0x5ACEAB53, 0xCEEFAB53, 0x4ECEAB53, 0xFAEFAB53, 0x7ECEAB53, 0xE6EFAB53, 0x66CEAB53, 0x92EFAB53, 0x06CEAB53, 0xBEEFAB53, 0xD6CFAB53, 0xAAEFAB53, 0xE2CFAB53, 0x56EFAB53, 0xA6CFAB53, 0x42EFAB53, 0x12CFAB53, 0x6EEFAB53, 0xCAD0AB53, 0x1AEFAB53, 0x46D0AB53, 0x06EFAB53, 0x06D0AB53, 0x32EFAB53, 0x26D0AB53, 0xDEF0AB53, 0xC6D1AB53, 0xCAF0AB53, 0xF2D1AB53, 0xF6F0AB53, 0x8ED1AB53, 0xE2F0AB53, 0xA6D1AB53, 0x8EF0AB53, 0x46D1AB53, 0xBAF0AB53, 0x62D1AB53, 0xA6F0AB53, 0x02D1AB53, 0x52F0AB53, 0xDAD2AB53, 0x7EF0AB53, 0xE6D2AB53, 0x6AF0AB53, 0x96D2AB53, 0x16F0AB53, 0xA6D2AB53, 0x02F0AB53, 0x6AD2AB53, 0x2EF0AB53, 0x02D2AB53, 0xDAF1AB53, 0xCED3AB53, 0xC6F1AB53, 0xFED3AB53, 0xF2F1AB53, 0x92D3AB53, 0x9EF1AB53, 0x5AD3AB53, 0x8AF1AB53, 0x1AD3AB53, 0xB6F1AB53, 0x0AD3AB53, 0xA2F1AB53, 0x36D3AB53, 0x4EF1AB53, 0xD2D4AB53, 0x7AF1AB53, 0xFED4AB53, 0x66F1AB53, 0x9AD4AB53, 0x12F1AB53, 0xAAD4AB53, 0x3EF1AB53, 0x7AD4AB53, 0x2AF1AB53, 0x6ED4AB53, 0xD6F2AB53, 0x16D4AB53, 0xC2F2AB53, 0x3AD4AB53, 0xEEF2AB53, 0xCAD5AB53, 0x9AF2AB53, 0xEAD5AB53, 0x86F2AB53, 0xA2D5AB53, 0xB2F2AB53, 0x42D5AB53, 0x5EF2AB53, 0x0ED5AB53, 0x4AF2AB53, 0x02D5AB53, 0x76F2AB53, 0x2AD5AB53, 0x62F2AB53, 0xC6D6AB53, 0x0EF2AB53, 0xBAD6AB53, 0x3AF2AB53, 0x5AD6AB53, 0x26F2AB53, 0x46D6AB53, 0xD2F3AB53, 0x72D6AB53, 0xFEF3AB53, 0x32D6AB53, 0xEAF3AB53, 0x22D6AB53, 0x96F3AB53, 0xCAD7AB53, 0x82F3AB53, 0xEAD7AB53, 0xAEF3AB53, 0x9AD7AB53, 0x5AF3AB53, 0x8AD7AB53, 0x46F3AB53, 0xB6D7AB53, 0x72F3AB53, 0xA2D7AB53, 0x1EF3AB53, 0x46D7AB53, 0x0AF3AB53, 0x6ED7AB53, 0x36F3AB53, 0x06D7AB53, 0x22F3AB53, 0x3AD7AB53, 0xCEF4AB53, 0xDED8AB53, 0xFAF4AB53, 0xCAD8AB53, 0xE6F4AB53, 0xEAD8AB53, 0x92F4AB53, 0x8AD8AB53, 0xBEF4AB53, 0xBED8AB53, 0xAAF4AB53, 0x5ED8AB53, 0x56F4AB53, 0x52D8AB53, 0x42F4AB53, 0x76D8AB53, 0x6EF4AB53, 0x1ED8AB53, 0x1AF4AB53, 0x0AD8AB53, 0x06F4AB53, 0x36D8AB53, 0x32F4AB53, 0xDAD9AB53, 0xDEF5AB53, 0xFED9AB53, 0xCAF5AB53, 0xE2D9AB53, 0xF6F5AB53, 0x96D9AB53, 0xE2F5AB53, 0x86D9AB53, 0x8EF5AB53, 0xB6D9AB53, 0xBAF5AB53, 0xA6D9AB53, 0xA6F5AB53, 0x4ED9AB53, 0x52F5AB53, 0x42D9AB53, 0x7EF5AB53, 0x6AD9AB53, 0x6AF5AB53, 0x02D9AB53, 0x16F5AB53, 0x32D9AB53, 0x02F5AB53, 0xD6DAAB53, 0x2EF5AB53, 0xCADAAB53, 0xDAF6AB53, 0xF2DAAB53, 0xC6F6AB53, 0x96DAAB53, 0xF2F6AB53, 0x8ADAAB53, 0x9EF6AB53, 0xB2DAAB53, 0x8AF6AB53, 0x56DAAB53, 0xB6F6AB53, 0x7EDAAB53, 0xA2F6AB53, 0x3EDAAB53, 0x4EF6AB53, 0x26DAAB53, 0x7AF6AB53, 0xCEDBAB53, 0x66F6AB53, 0xE2DBAB53, 0x12F6AB53, 0x8ADBAB53, 0x3EF6AB53, 0x46DBAB53, 0x2AF6AB53, 0x7ADBAB53, 0xD6F7AB53, 0x62DBAB53, 0xC2F7AB53, 0x16DBAB53, 0xEEF7AB53, 0x3EDBAB53, 0x9AF7AB53, 0x26DBAB53, 0x86F7AB53, 0xFEDCAB53, 0xB2F7AB53, 0xEEDCAB53, 0x5EF7AB53, 0x86DCAB53, 0x4AF7AB53, 0x46DCAB53, 0x76F7AB53, 0x66DCAB53, 0x62F7AB53, 0x26DCAB53, 0x0EF7AB53, 0xC2DDAB53, 0x3AF7AB53, 0xE2DDAB53, 0x26F7AB53, 0x82DDAB53, 0xD2F8AB53, 0xAEDDAB53, 0xFEF8AB53, 0x5EDDAB53, 0xEAF8AB53, 0x7EDDAB53, 0x96F8AB53, 0x12DDAB53, 0x82F8AB53, 0x06DDAB53, 0xAEF8AB53, 0xDADEAB53, 0x5AF8AB53, 0xC2DEAB53, 0x46F8AB53, 0xF6DEAB53, 0x72F8AB53, 0x8ADEAB53, 0x1EF8AB53, 0x42DEAB53, 0x0AF8AB53, 0x66DEAB53, 0x36F8AB53, 0x06DEAB53, 0x22F8AB53, 0xD2DFAB53, 0xCEF9AB53, 0xFEDFAB53, 0xFAF9AB53, 0x8EDFAB53, 0xE6F9AB53, 0xAADFAB53, 0x92F9AB53, 0x4ADFAB53, 0xBEF9AB53, 0x66DFAB53, 0xAAF9AB53, 0x3EDFAB53, 0x56F9AB53, 0xD6E0AB53, 0x42F9AB53, 0xC2E0AB53, 0x6EF9AB53, 0x9EE0AB53, 0x1AF9AB53, 0xA6E0AB53, 0x06F9AB53, 0x62E0AB53, 0x32F9AB53, 0x06E0AB53, 0xDEFAAB53, 0xD6E1AB53, 0xCAFAAB53, 0x9AE1AB53, 0xF6FAAB53, 0xBEE1AB53, 0xE2FAAB53, 0x4AE1AB53, 0x8EFAAB53, 0x6EE1AB53, 0xBAFAAB53, 0x0AE1AB53, 0xA6FAAB53, 0xCAE2AB53, 0x52FAAB53, 0xF6E2AB53, 0x7EFAAB53, 0xE6E2AB53, 0x6AFAAB53, 0x96E2AB53, 0x16FAAB53, 0x86E2AB53, 0x02FAAB53, 0x56E2AB53, 0x2EFAAB53, 0x62E2AB53, 0xDAFBAB53, 0x3EE2AB53, 0xC6FBAB53, 0xEAE3AB53, 0xF2FBAB53, 0x8AE3AB53, 0x9EFBAB53, 0xA2E3AB53, 0x8AFBAB53, 0x52E3AB53, 0xB6FBAB53, 0x7EE3AB53, 0xA2FBAB53, 0x6AE3AB53, 0x4EFBAB53, 0x06E3AB53, 0x7AFBAB53, 0x32E3AB53, 0x66FBAB53, 0xDEE4AB53, 0x12FBAB53, 0xFAE4AB53, 0x3EFBAB53, 0xE6E4AB53, 0x2AFBAB53, 0x92E4AB53, 0xD6FCAB53, 0xAEE4AB53, 0xC2FCAB53, 0x5EE4AB53, 0xEEFCAB53, 0x42E4AB53, 0x9AFCAB53, 0x12E4AB53, 0x86FCAB53, 0x02E4AB53, 0xB2FCAB53, 0xDEE5AB53, 0x5EFCAB53, 0xEAE5AB53, 0x4AFCAB53, 0x9EE5AB53, 0x76FCAB53, 0xAAE5AB53, 0x62FCAB53, 0x5EE5AB53, 0x0EFCAB53, 0x4EE5AB53, 0x3AFCAB53, 0x3EE5AB53, 0x26FCAB53, 0xDEE6AB53, 0xD2FDAB53, 0x00000000, 0x00000000, 0x2B8A463B, 0x009F369D]
orig_list = []
for i in xored_list:
    orig_list.append(swap32(i))

def norm(epc, addr):
    if epc == addr:
        return 0
    elif epc < addr:
        return -1
    else:
        return 1
base = 0x80028000
base2 = 0xbfc20000
def convert(addr):
    first = addr2000[0]
    tmp1 = 0
    tmp2 = 0
    while addr2000[1] != first:
        tt = addr2800[(first-base)//4]
        r = norm(addr, orig_list[(tt-base2)//4])
        if r == 1:
            first = addr2800[(first+0xC-base)//4]
            if first == addr2000[1]:
                break
            else:
                if tmp1 !=0:
                    break
        elif r==-1:
            first = addr2800[(first+8-base)//4]
            if first == addr2000[1]:
                break
            else:
                if tmp1 !=0:
                    break
        elif r==0:
            tmp1 = 1
            tmp2 = addr2800[(first - base)//4]
            if first == addr2000[1]:
                break
            else:
                if tmp1 !=0:
                    break

    return tmp2

def get_address(inaddr):
    xored = inaddr ^ x
    outaddr = xored
    r1 = convert(xored)
    if r1 != 0:
        outaddr = orig_list[(r1 + 4 - base2)//4]
    return outaddr ^ x

mp = {}
mpr = {}

for i in range(0x8000):
    addr = 0x80000000 + i
    outaddr = get_address(addr)
    mp[addr] = outaddr
    mpr[outaddr] = addr
    #print(f"{hex(addr)} => {hex(outaddr)}")

print(hex(mp[0x80000D50]))

这里 2800.dump 就是内存中 0x80002800 开始长度为 0x1000的内存。

有了这个程序之后，我们就可以来还原程序中的控制流了，比如刚才loc_80000D50 处的死循环实际上经过一次中断后会到达0x80002e34的位置开始下一段逻辑。整个程序基本上都是这样由无数个小片段来构成的，稍微花点功夫就可以人工把原控制流拼接起来。

定位验证逻辑

之后的难点是怎么定位输入验证逻辑。这里我的方法是首先在内存里搜索输入的字符串，比如flagPPPPP，可以搜索 0x5050(PP的ASCII)

1
2
3
4
5

pwndbg> find/h 0x80000000, 0x80010000, 0x5050
0x8000880a
0x8000880b
0x8000880c
3 patterns found.

实际上如果从 0x80008000 开始 dump 可以看到之前的输入，比如

1
2
3
4
5
6
7
8

pwndbg> hexdump 0x80008000 0x1000
+0000 0x80008000  00 00 18 04  31 32 33 34  35 36 00 33  34 35 36 7d  │....│1234│56.3│456}│
+0010 0x80008010  0a 00 00 00  00 00 00 00  00 00 00 00  00 00 00 00  │....│....│....│....│
+0020 0x80008020  00 00 00 00  00 00 00 00  00 00 00 00  00 00 00 00  │....│....│....│....│
...
+0800 0x80008800  00 00 00 00  66 6c 61 67  50 7f 50 50  50 50 0a 00  │....│flag│P.PP│PP..│
+0810 0x80008810  00 00 00 00  00 00 00 00  00 00 00 00  00 00 00 00  │....│....│....│....│
...

也就是说第一次输入是在 0x80008004，第二次是在0x80008804，然后以此类推。接下来重启程序，在输入 flag 之前在 0x80008004下一个读取断点，输入一个字符会立即触发，简单跟踪逻辑可以发现是遇到\n 的话就停止处理进入验证逻辑，接下来就是跟踪 flag如何被验证的了。

flag 验证

反复跟踪后可以发现在对我们的输入进行了一定预处理后，程序进入到了这样一段逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

ROM:8000081C ImportantStart:                          # CODE XREF: ROM:80002EE8↓p
ROM:8000081C
ROM:8000081C var_38          = -0x38
ROM:8000081C var_8           = -8
ROM:8000081C var_4           = -4
ROM:8000081C
ROM:8000081C                 addiu   $sp, -0x48
ROM:80000820                 sw      $ra, 0x48+var_4($sp)
ROM:80000824                 sw      $fp, 0x48+var_8($sp)
ROM:80000828                 move    $fp, $sp
ROM:8000082C                 sw      $zero, 0x48+var_38($fp)  # 0x800026ef
ROM:80000830                 mtc0    $zero, Count     # Timer Count
ROM:80000834
ROM:80000834 loc_80000834:                            # CODE XREF: ImportantStart:loc_80000834↓j
ROM:80000834                 b       loc_80000834     # next: 0x80002ab0

ROM:80002AB0                 b       loc_80000C9C
ROM:80002AB4                 nop

ROM:80000C9C loc_80000C9C:                            # CODE XREF: ROM:80002AB0↓j
ROM:80000C9C                                          # ROM:80002B28↓j ...
ROM:80000C9C                 lw      $v0, 0x10($fp)
ROM:80000CA0                 mtc0    $zero, Count     # Timer Count
ROM:80000CA4
ROM:80000CA4 loc_80000CA4:                            # CODE XREF: ROM:loc_80000CA4↓j
ROM:80000CA4                 b       loc_80000CA4     # next: 0x80002df8

ROM:80002DF8                 beqz    $v0, loc_8000083C
ROM:80002DFC                 nop
    ROM:8000083C loc_8000083C:                            # CODE XREF: ROM:80002DF8↓j
    ROM:8000083C                 la      $v0, word_80003D24
    ROM:80000844                 lw      $v0, 8($v0)      # flag code 0x80003d40
    ROM:80000848                 lhu     $v0, 0($v0)
    ROM:8000084C                 sh      $v0, 0x14($fp)
    ROM:80000850                 la      $v0, word_80003D24
    ROM:80000858                 lw      $v0, 8($v0)
    ROM:8000085C                 addiu   $v1, $v0, 2
    ROM:80000860                 la      $v0, word_80003D24
    ROM:80000868                 sw      $v1, 8($v0)
    ROM:8000086C                 lhu     $v0, 0x14($fp)
    ROM:80000870                 sltiu   $v1, $v0, 0xE
    ROM:80000874                 mtc0    $zero, Count     # Timer Count
    ROM:80000878
    ROM:80000878 loc_80000878:                            # CODE XREF: ROM:loc_80000878↓j
    ROM:80000878                 b       loc_80000878     # next: 0x80002ac4

    ROM:80002AC4                 beqz    $v1, loc_80000C98
    ROM:80002AC8                 nop
    ROM:80002ACC                 b       loc_8000087C
    ROM:80002AD0                 nop
        ROM:8000087C loc_8000087C:                            # CODE XREF: ROM:80002ACC↓j
        ROM:8000087C                 nop
        ROM:80000880                 sll     $v1, $v0, 2      # v0 selection
        ROM:80000884                 la      $v0, dword_80002690 
        ROM:8000088C                 addu    $v0, $v1, $v0
        ROM:80000890                 lw      $v0, 0($v0)
        ROM:80000894                 mtc0    $zero, Count     # Timer Count
        ROM:80000898
        ROM:80000898 loc_80000898:                            # CODE XREF: ROM:loc_80000898↓j
        ROM:80000898                 b       loc_80000898     # next: 0x80002ad8

        ROM:80002AD8                 jr      $v0
        ROM:80002ADC                 nop
ROM:80002E00                 b       goflagdivide
ROM:80002E04                 nop

ROM:80002690 dword_80002690: .word 0x800008A0, 0x800008EC, 0x80000938, 0x80000980, 0x800009CC
ROM:80002690                                          # DATA XREF: ROM:80000884↑o
ROM:80002690                 .word 0x80000A1C, 0x80000A70, 0x80000AFC, 0x80000B88, 0x80000BD0
ROM:80002690                 .word 0x80000C20, 0x80000C48, 0x80000C6C, 0x80000C84

这里最后的 jr $v0 实际上是从 0x80002690 的 14个子程序中选择了一个跳转，我卡了一段时间才反应过来是虚拟机，继续观察每个子程序的逻辑可以观察到这个虚拟机的信息：

• 0x80003d38 是 PC 计数器，虚拟机代码区起点为 0x80003d40
• 栈区为 0x80018000-0x80020000，没有寄存器，0x80003d24存储验证结果，0x80003d3c 是用户输入（不包含flag{}）
• 0x80000710 处的函数弹出栈顶的值。
• 0x80000794 处的函数把值压入栈顶。

简单的逆向后可以编写脚本生成虚拟机伪代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

import struct

orig = [0x10260080, 0x00000000, 0x00000000, 0x00000000, 0x00800180, 0x00000280, 0x00800180, 0x00000000, 0x1D090900, 0x00000900, 0x05000A00, 0x14000600, 0x01000900, 0x01000A00, 0x08000B00, 0x01000900, 0xE0FF0600, 0x11000900, 0x09000200, 0x030048B2, 0xA9720900, 0x07000500, 0x09004401, 0x02001100, 0x48B20900, 0x09000300, 0x05007E09, 0x2E010700, 0x11000900, 0x09000200, 0x030048B2, 0x60550900, 0x07000500, 0x09001801, 0x02001100, 0x48B20900, 0x09000300, 0x0500A14C, 0x02010700, 0x11000900, 0x09000200, 0x030048B2, 0x37000900, 0x07000500, 0x0900EC00, 0x02001100, 0x48B20900, 0x09000300, 0x050071AA, 0xD6000700, 0x11000900, 0x09000200, 0x030048B2, 0x2C120900, 0x07000500, 0x0900C000, 0x02001100, 0x48B20900, 0x09000300, 0x05003645, 0xAA000700, 0x11000900, 0x09000200, 0x030048B2, 0xE8110900, 0x07000500, 0x09009400, 0x02001100, 0x48B20900, 0x09000300, 0x05004712, 0x7E000700, 0x11000900, 0x09000200, 0x030048B2, 0xC7760900, 0x07000500, 0x09006800, 0x02001100, 0x48B20900, 0x09000300, 0x05006D09, 0x52000700, 0x11000900, 0x09000200, 0x030048B2, 0x2C120900, 0x07000500, 0x09003C00, 0x02001100, 0x48B20900, 0x09000300, 0x0500CB87, 0x26000700, 0x11000900, 0x09000200, 0x030048B2, 0xE4090900, 0x07000500, 0x09001000, 0x07001D09, 0x09000800, 0x0B000000, 0x09000D00, 0x0B000100, 0xDDE40D00, 0x6C6C7CAC, 0xD8B41BC8, 0xBAD7365B, 0x183F502C, 0xA1D248EF, 0xFF5A2F91, 0xA868CC67, 0xE48978A1, 0x54B968BF, 0x0065E01D, 0x0A0E4574, 0x6AE27932, 0x3B337A5A, 0x70A5812A, 0x66178002, 0xF7A600A2, 0x2097FD67, 0x69BD7DB9, 0xC3BC4229, 0xCBDB5CB8, 0x491B2CCB, 0xFD93B6D1, 0xD9735472, 0xC953C3EB, 0x44A8341C, 0x21F987F1, 0x163FECE8, 0x969EF4C6, 0x5422BDAA, 0x769F2DB0, 0x3A384F0E, 0xCE22439D, 0x1C845620, 0xE22838CE, 0x59E20579, 0x1FED8C37, 0x9CA5E63B, 0xC1D78E1E, 0x0B9DA21F, 0xADAAA050, 0x3B3FF509, 0xE5F0A239, 0x74ED3875, 0xF428491E, 0x045988C6, 0xCE79945F, 0x306D11E0, 0x8B5A4388, 0x0D2A4365, 0x06155428, 0x47D87921, 0x933CB9DB, 0x1AE5B43A, 0xEB9C3573, 0xB0A3CBB8, 0xA9E07C20, 0x376A7E60, 0x3AC87999, 0xFF22732E, 0x5AECA38D, 0x9080C504, 0xA63CA03B, 0x4A2D3659, 0x7CE34674, 0x6F42F442, 0x180E34CC, 0xBE6771C2, 0x8E93EE6D, 0xA00E7012, 0x98BFC4C1, 0x78A3A1FC, 0xF17FA9DD, 0xD85B22F0, 0x096CBB37, 0x01329A96, 0xF456E6BA, 0xB2696C61, 0xA0F3B059]

addr3d20 = [0 for i in range(len(orig))]

addr82000 = [0 for i in range(0x1000)]

addrflag = [0 for i in range(0x10)]

for i in range(0x10):
    addrflag[i] = ord('a') + i 

baseflag = 0x80008004

base2 = 0x80018000

base = 0x80003d20

fp = [0 for i in range(100)]


#https://stackoverflow.com/questions/27506474/how-to-byte-swap-a-32-bit-integer-in-python
def swap32(i):
    return struct.unpack("<I", struct.pack(">I", i))[0]

def pp(l):
    for i in l:
        print(hex(i))

def pp2(l):
    print(" ".join(map(hex, l)))

for i in range(len(addr3d20)):
    addr3d20[i] = swap32(orig[i])

def sub_read():
    global ptr
    ptr -= 1
    return area[ptr]

def write_add(a0):
    global ptr, area
    area[ptr] = a0
    ptr += 1

def ss(v):
    v = v + (v>>31)
    return ((v>>1)<<1)

idx = 0x80003d40
ptr = 0
area = [0 for i in range(0x200)]

plus2 = set([
    6,7,9
])

flag = "flag{123456789123456789}"
divide_flag = 9 # 0x80003d24 origin (len+1)/2
flagptr = 0
mdd= 0x3bbc9
cmds = {
    0x9 : "push",
    0xa : "push divide flag",
    0x5 : "cmp",
    0x6 : "jneqz",
    0x7 : "jeqz",
    0x1 : "sub",
    0x0 : "add",
    0x2 : "mul",
    0x3 : "mod",
    0x4 : "cmpless",
    0x8 : "push flag",
    0xB : "pop divide flag",
    0xC : "subptr",
    0xD : "end"
}

while True:
    current_addr = idx
    second = None
    if (idx - base) % 4 == 0:
        wd = addr3d20[(idx - base)//4]
    else:
        wd = ((addr3d20[(idx - base)//4] & 0xFFFF) << 16 ) + ((addr3d20[(idx - base)//4 + 1] & 0xFFFF0000) >> 16)
    first = (wd & 0xFFFF000) >> 16
    idx += 2
    if first in plus2:
        second = wd & 0xFFFF
        if (first == 0x6 or first == 0x7) and second > 0x1000:
            second = second - 0x10000
        print(f"{hex(current_addr - 0x80003d40)} {hex(first)} {cmds[first]} {hex(second)}")
        idx += 2
    else:
        print(f"{hex(current_addr - 0x80003d40)} {hex(first)} {cmds[first]}")
    if first == 0xD:
        break
    elif first < 0xD:
        if first == 0x9:
            write_add(second)
        elif first == 0xa:
            write_add(divide_flag)
        elif first == 0x5:
            r = sub_read() ^ sub_read()
            if r < 1:
                r = 0
            else:
                r = 1
            write_add(r)
        elif first == 0x6:
            if sub_read() == 0:
                continue
            #idx += ss(second)
        elif first == 0x7:
            if sub_read() != 0:
                continue
            #idx += ss(second)
        elif first == 0x1:
            r = sub_read() - sub_read()
            write_add(r)

最后可以得到关键验证逻辑的伪代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

0x0 0x9 push 0x91d
0x4 0x9 push 0x0
0x8 0xa push divide flag
0xa 0x5 cmp
0xc 0x6 jneqz 0x14 => 0x24
0x10 0x9 push 0x1
0x14 0xa push divide flag
0x16 0x1 sub
0x18 0xb pop divide flag
0x1a 0x8 push flag
0x1c 0x9 push 0x1
0x20 0x6 jneqz -0x20 => 0x4
0x24 0x9 push 0x11
0x28 0x2 mul # mul last two bytes of flag
0x2a 0x9 push 0xb248
0x2e 0x3 mod # result % 0xb248
0x30 0x9 push 0x72a9
0x34 0x5 cmp
0x36 0x7 jeqz 0x144 => 0x17C fail
0x3a 0x9 push 0x11
0x3e 0x2 mul
0x40 0x9 push 0xb248
0x44 0x3 mod
0x46 0x9 push 0x97e
0x4a 0x5 cmp
0x4c 0x7 jeqz 0x12e
0x50 0x9 push 0x11
0x54 0x2 mul
0x56 0x9 push 0xb248
0x5a 0x3 mod
0x5c 0x9 push 0x5560
0x60 0x5 cmp
0x62 0x7 jeqz 0x118
0x66 0x9 push 0x11
0x6a 0x2 mul
0x6c 0x9 push 0xb248
0x70 0x3 mod
0x72 0x9 push 0x4ca1
0x76 0x5 cmp
0x78 0x7 jeqz 0x102
0x7c 0x9 push 0x11
0x80 0x2 mul
0x82 0x9 push 0xb248
0x86 0x3 mod
0x88 0x9 push 0x37
0x8c 0x5 cmp
0x8e 0x7 jeqz 0xec
0x92 0x9 push 0x11
0x96 0x2 mul
0x98 0x9 push 0xb248
0x9c 0x3 mod
0x9e 0x9 push 0xaa71
0xa2 0x5 cmp
0xa4 0x7 jeqz 0xd6
0xa8 0x9 push 0x11
0xac 0x2 mul
0xae 0x9 push 0xb248
0xb2 0x3 mod
0xb4 0x9 push 0x122c
0xb8 0x5 cmp
0xba 0x7 jeqz 0xc0
0xbe 0x9 push 0x11
0xc2 0x2 mul
0xc4 0x9 push 0xb248
0xc8 0x3 mod
0xca 0x9 push 0x4536
0xce 0x5 cmp
0xd0 0x7 jeqz 0xaa
0xd4 0x9 push 0x11
0xd8 0x2 mul
0xda 0x9 push 0xb248
0xde 0x3 mod
0xe0 0x9 push 0x11e8
0xe4 0x5 cmp
0xe6 0x7 jeqz 0x94
0xea 0x9 push 0x11
0xee 0x2 mul
0xf0 0x9 push 0xb248
0xf4 0x3 mod
0xf6 0x9 push 0x1247
0xfa 0x5 cmp
0xfc 0x7 jeqz 0x7e
0x100 0x9 push 0x11
0x104 0x2 mul
0x106 0x9 push 0xb248
0x10a 0x3 mod
0x10c 0x9 push 0x76c7
0x110 0x5 cmp
0x112 0x7 jeqz 0x68
0x116 0x9 push 0x11
0x11a 0x2 mul
0x11c 0x9 push 0xb248
0x120 0x3 mod
0x122 0x9 push 0x96d
0x126 0x5 cmp
0x128 0x7 jeqz 0x52
0x12c 0x9 push 0x11
0x130 0x2 mul
0x132 0x9 push 0xb248
0x136 0x3 mod
0x138 0x9 push 0x122c
0x13c 0x5 cmp
0x13e 0x7 jeqz 0x3c
0x142 0x9 push 0x11
0x146 0x2 mul
0x148 0x9 push 0xb248
0x14c 0x3 mod
0x14e 0x9 push 0x87cb
0x152 0x5 cmp
0x154 0x7 jeqz 0x26
0x158 0x9 push 0x11
0x15c 0x2 mul
0x15e 0x9 push 0xb248
0x162 0x3 mod
0x164 0x9 push 0x9e4
0x168 0x5 cmp
0x16a 0x7 jeqz 0x10
0x16e 0x9 push 0x91d
0x172 0x7 jeqz 0x8
0x176 0x9 push 0x0
0x17a 0xb pop divide flag
0x17c 0xd end

逻辑非常直白，读入所有用户输入后，倒着每两个字节和 0x11 相乘然后对0x0b248 取模看是否等于特定的数值，写一个脚本直接算出 flag。

1
2
3
4
5
6
7
8
9

toequal = [0x72a9, 0x97e, 0x5560, 0x4ca1, 0x37, 0xaa71, 0x122c, 0x4536, 0x11e8, 0x1247, 0x76c7, 0x96d, 0x122c, 0x87cb, 0x9e4]
fl = ""
for eq in toequal:
    for i in range(0xFFFF):
        if i * 0x11 % 0xb248 == eq:
            print(f"last two bytes: {struct.pack('>H', i)}")
            fl = struct.pack('>H', i).decode("utf-8") + fl
            break
print(fl)

得到 flag 为 flag{it's_time_to_pwn_this_machine!}。

后记

一瓶可乐一包零食，一个逆向做一天。

不得不说这次 TCTF 2020第一道逆向题就给我带来了非常大的惊喜浪费了我一天半的时间，帮我复习了一大波mips知识还有操作系统的基础知识，让我见识到了程序还能这样执行。如果有可能，我倒是更想知道这道题是怎么出的。:)

上文中的脚本和IDA数据库均已经打包，见这里。

Reference

• Slide
• Mars
• MipsIS

最近终于稍微闲了一点可以花点时间把博客整理一下了你鸽了多久心里没数吗，这篇文章算是这个过程中的一些碎碎念吧。

本文为非技术文章。

备案以及域名更换

有些人可能注意到本博客的域名从 https://ihomura.cn 正式更换到了https://blog.ihomura.cn ，然而这背后的故事还得从 Azure 说起。

大概一个月前，我在跟别人聊天的时候发现我的博客证书居然过期了。当时我的博客是托管在AzureCDN上，由AzureCDN负责自动申请新证书，所以我第一时间登录了控制台，结果一看，原来是新增加了一个选项TLS1.1/TLS1.2需要设置后才能签新证书，但是我选择任意一个都没法保存，这时候右上角的提示就有意思了。

这我就想不通了，既然没法给顶级域名签发证书，为什么不发个邮件提醒一下呢？就算没提醒好歹控制台直接告诉我原因也行吧，结果只有到保存的时候才告诉真实原因，不知道是什么思路。

吐槽归吐槽，那不得赶紧换域名，然后我轻车熟路重新上了个https://blog.ihomura.cn ，设置好了 CNAME提交HTTPS证书配置请求就去睡觉了，结果第二天起来一看域名所有权还没审核通过，读了文档才知道一般这种情况是验证失败，需要向域名邮箱发送确认邮件。

好嘛，那我就再等等，结果这封邮件直到我从 Azure CDN删除了所有配置后的第七天才抵达我的邮箱 :)

所以当时等了两天后我决定直接放弃 AzureCDN，但是域名没有备案，考察了一圈免备案 CDN后，出于没钱各种原因，想了想反正已经关站两三天了，不如就直接备案得了，于是在腾讯云购买了一个云服务器走备案流程。具体的坑就不表了，在等待了十多天后我的备案号终于下来了，现在博客整体迁移到了腾讯云CDN，不过也只是先试用，之后还会考察一些其他 CDN。

换了国内 CDN 后，我的体验只有三点：快，快，还是TMD快！之前 Azure CDN国内是香港直连，延迟大概100ms左右，虽然不能说慢，但是一个要命的问题是基础版的命中率太低了，很容易出现TCP_MISS 降低第一次打开时候的体验，相比之下腾讯云在缓存稳定后命中率能有80%，而且延迟只有10ms左右，高下立判。

另外因为备案后条条框框就多了很多，所以目前本博客的评论系统暂时关闭，考虑未来采用一些第三方的评论系统然后把整个博客扔到github pages上，但是我还是喜欢把博客所有数据自己保存，因此目前大方向还没有定。想讨论的可以去关于页面找到我的联系方式。

NexT 升级

实际上时间主要就是花在了 NexT 升级上，因为我 NexT有一年多没有动了，直接落下了 800+ 的 commit，再加上我的各种hack，我merge 做到一半就直接放弃了，直接从头配了一遍。

带来最大的变化相信各位读者已经注意到了，那就是Darkmode，这得益于升级了NexT，不得不说作为一个程序员还是要偏爱深色模式的。

另外代码块也设置了相应的主题避免突然瞎眼:)。

RSS

现在博客已经支持 RSS了，各位读者可以自行订阅。

或者可以尝试 RSS2。

英文博客

其实让我下定决心备案的另外一个原因就是我另外开了一个英文博客挂在github pages 上，所以这个博客就专心给国内用户提供服务了。

英文博客的地址为 https://blog.lazym.io，目前在写一些有意思的东西，欢迎关注。

小结

虽然看起来花了很多时间，但是实际上做的事情也并不多，希望接下来能给各位读者带来满意的知识输出。

最近研究 Chromium 和 HTML 标准，不可避免的就接触到了 WebIDL，这里就总结性的聊聊吧，也当是学习笔记了。

本文几乎就是照搬现在 Web IDL的标准，但也不是简单的翻译也翻译不准。

简介

Web IDL 全称 Web Interface Definition Language。现在 Web IDL只有第一版，是 W3C 2016年出的，然而现在几乎没有人用它，大家用的都是还在草案阶段的第二版。这里忍不住道一点题外话，之前W3C 和 WHATWG 闹掰，W3C 的想法是在积累一定的 Fix 后就固定版本而 WHATWG希望是对标准不断修补，结果 HTML5 标准一直有两个，直到今年 5 月底 W3C 和WHATWG 才宣布共同维护一个标准。而在 Web IDL第二版草案成为实质标准的现在可以看出，搞个固定的版本明显是没人喜欢用的，大家还是喜欢最新的标准，像以前HTML1 - HTML4 那种一个版本一个脚印的时代已经不存在了，不太理解 W3C的想法。

说回正题，那么为什么需要 Web IDL？首先在 Web IDL之前已经有一种类似的语言叫做 OMGIDL 用来定义 W3C各个标准中的各种对象，然而由于 ECMAScript定义并不够精确所以在互相操作和使用的过程中出现了问题，并且每个标准总是在用OMGIDL 重复描述一些常见的对象造成了冗余，为了解决这些问题就有了 WebIDL。所以 Web IDL 的主要目标是

• 精确定义浏览器内部各种接口
• 严谨定义 ECMAScript 和 Web IDL 的绑定

围绕着这两方面，Web IDL 的标准主要有两部分：Interface definitionlanguage 和 ECMAScript bindings。

IDL

Identifier

Web IDL的标识符很简单，稍微特殊一点的是，一般的属性标识符应该避免以下划线开头因为以下划线开头的标识符是保留标识符，而且标识符开头的下划线会被移除。这样说有点抽象，不如看个例子。

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

// Typedef identifier: "number"
typedef double number;

// Interface identifier: "System"
[Exposed=Window]
interface System {

  // Operation identifier:          "createObject"
  // Operation argument identifier: "interface"
  object createObject(DOMString _interface);

  // Operation argument identifier: "interface"
  sequence<object> getObjects(DOMString interface);

  // Operation has no identifier; it declares a getter.
  getter DOMString (DOMString keyName);
};

// Interface identifier: "TextField"
[Exposed=Window]
interface TextField {

  // Attribute identifier: "const"
  attribute boolean _const;

  // Attribute identifier: "value"
  attribute DOMString? _value;
};

这里最后的 _const 实际标识符是const，_value 也是同理。

Interface

基础语法

最重要的就是接口了，Web IDL 的接口语法和 Java稍微有些类似，语法很简单。

1
2
3
4

[extended_attributes]
interface identifier {
  /* interface_members... */
};

Partial interface

这里 interface 还支持 partial interface，熟悉 C# 的 partial class应该就马上理解了，实际上就是把一个类的定义分开写，不过文档里面提到这个特性只是为了方便书写标准设计的，实现并不一定使用。比如

1
2
3
4
5
6
7