Rebel Zhang 的博客

关于我的常见问题

rebel1725@tilde.club (Rebel Zhang) — Wed, 26 Aug 2026 18:54:57 +0800

这里是一系列关于我的常见问题。

你是谁？

我是来自中国的自由软件倡导者和爱好者，同时也关注安全、隐私以及其他数字权利相关的问题。

为什么叫 Rebel？

作为一个人名，“Rebel”通常与独立、不墨守成规以及反抗精神等特质联系在一起。它象征着一个不害怕挑战社会规范或期望的人。

我认为这个名字很适合我，因为我是一名坚定反对专有软件的自由软件倡导者。

为什么是 `rebel1725`？

rebel 的原因很明显；请参阅上一问。1725 的原因是，1725 就是 1/7/25，也就是这个身份诞生的那一天。

什么是你的个人品牌体系？

请参阅此页面。

你是什么时候接触到这些自由软件相关的东西的？

从 2022 年夏季开始，我受到 gnu.org 和 fsf.org 上的观点和论述的影响。2022 年 7 月 16 日，我从电脑上卸载了 Microsoft Windows，并开始逐一替换电脑和手机上的专有应用程序；到 2023 年 4 月底，我开始使用 LineageOS；2024 年 7 月，我更换了自己的身份，并在用户空间实现了 100% 自由软件。

你如何看待专有软件？

所有专有软件无一例外都是不道德且不公正的，它们践踏了计算机用户的四项基本软件自由以及人类道德的基本原则，因此不应存在。

除了道德层面的问题之外，专有软件通常还是恶意软件和间谍软件，这也会带来隐私和安全方面的实际问题，因此应当避免使用。

你如何看待自由和非自由文化作品（例如音乐、电影等）？

我确实支持自由文化作品，并且经常把它们用作我的手机铃声、壁纸等。不过，与软件不同，我并不反对非自由文化作品，我也经常听 Alan Walker、Taylor Swift、Sia、TheFatRat 等人演唱的歌曲。那些将自己的作品奉献给自由文化社区的人确实值得尊敬，但（至少我认为）那些保留其作品全部权利的人也没有做错什么。

然而，如果非自由文化作品被捆绑进软件中，我认为这是不可接受的，因为这会使软件变成专有软件。

你的设备配置是什么？

我有许多设备，并为每一台设备都取了名字。以下是截至 2026-08-25 的部分设备详细信息：

名称	型号	操作系统
Warden	GL.iNet Flint 2	OpenWrt
Alaric	Lenovo ThinkPad X200	Trisquel GNU/Linux
Bryna	Xiaomi Redmi G Pro 2024	Qubes OS
Ami	HP EliteBook 820 G2	Qubes OS
Leo	OnePlus 11	LineageOS
William	Google Pixel 6	GrapheneOS
Gemini	TicWatch Pro 2018	AsteroidOS

你每天使用什么软件？

下面是不完整的日常软件列表：

浏览器：LibreWolf、Tor Browser、Fennec F-Droid；
办公：LibreOffice、Okular、MuPDF；
开发：GNU Emacs、Kate、Geany；
邮件：Thunderbird；
图形：GIMP、Krita；
多媒体：VLC、Rhythmbox、Kdenlive、Audacity、Booming Music；
安全：KeePassXC、Kleopatra、OpenKeychain。

你目前的软件自由状态如何？

现在，我在所有日常使用的设备上，都不会在用户空间使用任何专有软件。Alaric 和 Ami 都配备了 Libreboot，而 Bryna 仍然运行非自由的 UEFI，但至少它的硬盘中除了固件和微码之外，不再有其他非自由二进制文件。我的手机都运行 LineageOS、GrapheneOS 或 postmarketOS 之类的自由软件操作系统；在 Android 系统上，我只使用预装应用或来自 F-Droid 的应用；在 postmarketOS 上，我只使用官方软件仓库中的应用，或者我自己构建的应用。

那么你的技术栈呢？

我的编程能力非常基础，而且目前仍然可以算是比较差。截至 2026 年 8 月 25 日，我掌握了 C/C++、Python、Shell 等的基础知识。我能够在一定程度上使用 C++ 和 Qt Widgets 开发一些应用，最近也一直在学习 Qt Quick。我也曾尝试学习 Rust，但目前已经暂时放弃。

我重点学习逆向工程，为此学习了 AArch64 汇编和 x86_64 汇编。不过，我目前的 RE 技能仍然只限于简单的 crackme。但我正在努力学习更多内容，我的目标是制作一个 postmarketOS 移植版本。

你主要使用哪些通信工具？

我主要使用 XMPP 与朋友和熟人交流，使用 Matrix 参与全球社区，使用 SimpleX 面向注重匿名性的用户（主要来自 I2P）。

总体而言，我使用最多的通信工具是 XMPP。

“Private”、“Express”和“Public”是什么意思？

这是我的即时通讯账号的三个隐私等级：

Private：这些账号用于私聊。你可以通过这些账号和我谈论几乎任何事情；但是，你不应期待快速回复，因为我只有在家时才能访问这些账号。
Express：这些账号同样用于私聊，并且可以在我带出门的设备上访问。不过，由于公共场所普遍存在监控，而且我的设备因为引导加载程序处于解锁状态而安全性降低，请在聊天时避免讨论敏感信息。
Public：这些账号仅用于公开聊天，以及有时使用未加密的私聊。聊天时请避免讨论敏感信息。

你是如何上网的？

我 24/7 使用 Tor。在电脑上，我使用 Tor 守护进程；在手机上，我使用 InviZible Pro。

有时，当我的 Tor 守护进程遇到问题时，我会使用 I2P 内的出口代理（outproxy）来访问互联网。

如何访问你的复古风格网站？

我有两个版本的复古风格网站。一个是普通的 HTTP/HTTPS 网站，另一个是 Gemini capsule（Gemsite）。它们是两个不同的网站。如果我没有特别说明而说“我的复古风格网站”，默认指的是 HTTP/HTTPS 版本。

我会把我的复古风格网站（HTTP/HTTPS 和 Gemini）托管在我加入的所有 Tilde 社区的服务器上，理论上你可以从其中任何一个服务器访问它们。不过，由于这些社区大多是爱好者建立的，因此会有停机时间。因此，我推荐访问托管在 Tilde.club 上的网站（HTTPS、Gemini），因为它最稳定，而且我对它投入的关注最多，我也会尽量确保其中的信息保持最新。其他 Tilde pubnix 上的内容理论上与 Tilde.club 上的内容相同，但不保证及时更新。

此外，这个复古风格网站（HTTP 版本）也作为 eepsite 托管在 I2P 网络上。它由 Catto Garden 用心托管，可通过 rebel1725.i2p 访问（Address Helper)。过去并不推荐通过这种方式访问网站，因为在没有配置出口代理的情况下，明网资源会无法加载；不过现在已经不是这样了，因为我改变了图片和其他资源的托管方式。

如何访问你的现代风格网站？

点击这里。

你玩游戏吗？

过去，我会玩 SuperTuxKart 和其他自由游戏。不过现在我很少玩游戏，因为 Qubes OS 让游戏体验变得很脆弱。而且，我一直反对专有游戏和 Digital Restrictions Management。

你如何听音乐？

我会从各种来源下载音乐，主要是 YouTube，而 yt-dlp 对此非常有帮助。如果我想支持艺术家，我会购买 CD。

我会把收听记录同步到 ListenBrainz，并从该平台获得个性化推荐。我的 ListenBrainz 个人资料在这里。

为什么你不为自己的 OpenPGP 密钥（或者至少其中一个子密钥）使用抗量子算法？

我想这么做，但我的硬件令牌不支持这类算法。

你的政治观点是什么？

我的政治观点可以概括如下：

自由很重要，包括但不限于软件、文化、言论、集会、结社、新闻出版等方面。软件自由尤其重要，任何限制这种自由的技术，包括但不限于数字限制管理、SaaSS 等，都不应存在。
我反对资本主义、帝国主义、种族主义、法西斯主义、纳粹主义、军国主义、威权主义、极权主义、独裁、审查、酷刑、仇外主义、战争，以及基于任何特征的歧视，包括但不限于国籍、宗教、残疾、年龄、阶级、性取向、性别/性别认同等。
隐私是基本人权之一，大规模监控应当被废除。
地球只有一个，人类应当努力保护我们唯一的家园。

为什么你使用英式英语而不是美式英语？

因为我不喜欢美国，因为其政府利用 PRISM 在全球范围内对计算机用户进行大规模监控。此外，大多数专有软件都在美国开发。

你认为自己外向且随和吗？

这取决于情况。

如果你是自由软件倡导者、自由软件爱好者或 GNU/Linux 爱好者，你可能确实会觉得我是一个外向而随和的人。如果你是陌生人，你可能会觉得我有点社交被动或内向。但如果你支持专有软件，我觉得你应该滚蛋。

我对亲密朋友设定了非常高的标准，但一旦你达到这些标准，我就会全心全意地投入我们的友谊。

你如何看待爱情？

在我看来，爱情与友谊并没有太大区别，但它天然包含更高的期待。真正的爱情应当建立在共同的理想和共同的信念之上；对我而言，这意味着对自由软件的共同承诺。

我的理想伴侣应该是一名自由软件倡导者，最好会说中文。我还写过一首诗，用来描绘我理想中的爱情。

你的 MBTI 是什么？

我是 ESTJ。

你的性别认同和性取向是什么？

我的代词是 he/him，我是异性恋。

想进一步了解这件事，请阅读这篇文章。

你如何看待 LGBTQ+？

我本人并不属于 LGBTQ+，但我努力变得更加尊重他人并且更加包容。

你的时区是什么？

Asia/Shanghai，即 UTC+08:00，且不实行夏令时。

使用 GammaRay 在 QtWidgets 应用程序中找到某个功能的实现

rebel1725@tilde.club (Rebel Zhang) — Sun, 09 Aug 2026 20:49:33 +0800

为了实践自由软件的自由 1 和自由 3，和/或为自由软件社区做出贡献，我们需要修改与某个功能相关的源代码，让软件做出不同的事情。然而，由于我们对某个项目并不熟悉，我们常常不知道需要修改的源代码在哪里。你可以试着运行 grep -R <some-user-facing-string> .，不过有时这并不会奏效（见上一篇文章）。在那种情况下，我们就需要一些高级的软件内省工具。对于使用 Qt 开发的软件，一个强大的工具是 GammaRay。

要使用 GammaRay，你首先需要安装它。如果你想检查从发行版官方软件仓库安装的软件，那么也请从那里安装 GammaRay：

# apt install gammaray

如果你使用 kde-builder 开发 KDE 应用程序，请将以下几行添加到你的 ~/.config/kde-builder.yaml：

project gammaray:
  repository: https://github.com/KDAB/GammaRay.git

然后把它构建到你的工作目录中：

$ kde-builder gammaray

要使用 GammaRay，你需要先让你想检查的应用程序运行起来。然后启动 GammaRay，并在列表中选择你的应用程序。

我们以在 Gwenview 中查找幻灯片逻辑为例。打开 Gwenview，然后打开一张图片，你会在菜单中看到 Start Slideshow 选项：

逐个浏览 Widgets 列表后，你会发现 0x13bda470 就是我们想要检查的菜单，其中包含 Start Slideshow 选项：

而且我们会在 Connections 标签页中看到一个 toggle_slideshow QAction：

grep 会告诉我们这样的 QAction 位于哪里：

~/kde/src/gwenview$ grep -R toggle_slideshow
app/fullscreencontent.cpp:    addAction(QStringLiteral("toggle_slideshow"));
app/gwenviewui.rc:        <Action name="toggle_slideshow" />
app/mainwindow.cpp:        mToggleSlideShowAction = view->addAction(QStringLiteral("toggle_slideshow"), q, &MainWindow::toggleSlideShow);

在你常用的 IDE 中打开该项目，例如 Qt Creator，然后在 app/mainwindow.cpp 中搜索这个字符串。我们会在这里找到 toggle_slideshow：

        mToggleSlideShowAction = view->addAction(QStringLiteral("toggle_slideshow"), q, &MainWindow::toggleSlideShow);
        q->updateSlideShowAction();
        connect(mSlideShow, &SlideShow::stateChanged, q, &MainWindow::updateSlideShowAction);

现在再搜索 toggleSlideShow，它会带我们找到这个函数：

void MainWindow::toggleSlideShow()
{
    if (d->mSlideShow->isRunning()) {
        d->mSlideShow->pause();
    } else {
        if (!d->mViewAction->isChecked()) {
            d->mViewAction->trigger();
        }
        if (!d->mFullScreenAction->isChecked()) {
            d->mFullScreenAction->trigger();
        }
        QList<QUrl> list;
        for (int pos = 0; pos < d->mDirModel->rowCount(); ++pos) {
            QModelIndex index = d->mDirModel->index(pos, 0);
            KFileItem item = d->mDirModel->itemForIndex(index);
            MimeTypeUtils::Kind kind = MimeTypeUtils::fileItemKind(item);
            switch (kind) {
            case MimeTypeUtils::KIND_SVG_IMAGE:
            case MimeTypeUtils::KIND_RASTER_IMAGE:
            case MimeTypeUtils::KIND_VIDEO:
                list << item.url();
                break;
            default:
                break;
            }
        }
        d->mSlideShow->start(list);
    }
    updateSlideShowAction();
}

继续搜索 mSlideShow，你会找到这里：

struct MainWindow::Private {
    ...
    SlideShow *mSlideShow = nullptr;
    ...
}

现在我们知道 d->mSlideShow 的类型是 SlideShow *。把鼠标悬停在 SlideShow 这个字符串上，会告诉我们它的类型来自 lib/slideshow.h。

现在打开 lib/slideshow.cpp 和 lib/slideshow.h，你就可以继续往下找了。

我为自由软件社区贡献的最初几步（现有项目）

rebel1725@tilde.club (Rebel Zhang) — Sun, 02 Aug 2026 23:18:30 +0800

近些天来，我对自由软件社区的贡献远远少于我从中受益的程度，而我所做出的贡献也仅限于一些小而简单的个人项目以及非代码类贡献（例如一些翻译、向 Debian Screenshots 上传几张截图，以及为 Free Software Chinese Site 撰写文章）。在过去的一年里，我学习了 C/C++、Qt、汇编，以及一些 Rust。我认为，现在是时候为自由软件社区和自由软件运动做一些有意义的事情了。

免责声明：这不是一篇指南！我撰写这篇文章，只是为了分享我自己的经历。请参考相关文档，并向专家请教，以进一步了解如何为自由软件社区做出贡献。

我为什么选择 KDE

最初，我曾考虑为 postmarketOS 贡献。不过，我觉得自己的技能距离所需水平还差得很远，于是决定先从相对简单的事情开始。由于我对 C++ 和 Qt 更熟悉，所以我选择 KDE 作为我对社区的第一次贡献。

感受

我阅读源代码的能力并不强。大约在 2025 年初，我尝试阅读 PDF Arranger 的源代码，当时我感到非常难受，也有些不知所措。

不过，得益于学习逆向工程的经历，而这恰好需要阅读汇编代码，我阅读高级语言源代码的能力也有所提升。因此，我认为自己应该尝试一次真正的自由软件贡献，在真实环境中练习自己的技能。

在打开源码树之前，我有些紧张，担心自己会像读 PDF Arranger 的源代码时那样，被庞大的代码淹没。多亏了朋友 Integral 的鼓励，我才鼓起勇气迈出那一步。

工具

KDE 推荐的开发环境之一是最新版的 Fedora KDE。由于我使用的是 Qubes OS，所以我可以很方便地快速搭建一个独立的 HVM，并在其中完成所有工作。

随后，我按照 KDE 开发者的官方文档配置了 kde-builder。

工作过程

我浏览了 KDE 官方 Bugzilla 上托管的漏洞列表。我注意到一个看起来非常容易修复的漏洞，但在拉取源代码并构建二进制文件之后，我发现这个漏洞在我当前环境下，使用最新版本的 Ark 无法复现。

随后我又回到漏洞列表，发现了另一个看起来很简单的漏洞。该漏洞报告中的系统环境和软件版本与我的相同（Fedora KDE，26.04），而且在 Fedora 官方仓库提供的应用程序中可以复现。确认这一点之后，我拉取了源代码并进行了构建。

我在二进制文件 ~/kde/build/konsole/bin/konsole 上启动了 GDB。把漏洞报告中提到的字符串（calt,liga,ss03, ss07,ss09）粘贴到输入框后，我在终端里看到了如下输出：

The tag name must be exactly 4 characters long!

在与一个 LLM 进行了几轮交流之后，我找到了一种用 GDB Python 脚本定位源码中打印这条提示的代码行的方法：

python
import gdb

TARGET = b"The tag name must be exactly 4 characters long!"

class FilteredWrite(gdb.Breakpoint):
    def stop(self):
        fd = int(gdb.parse_and_eval("$rdi"))
        if fd not in (1, 2):
            return False

        buf = int(gdb.parse_and_eval("$rsi"))
        count = int(gdb.parse_and_eval("$rdx"))

        try:
            data = gdb.selected_inferior().read_memory(buf, count).tobytes()
        except gdb.MemoryError:
            return False

        if TARGET in data:
            gdb.write("\n=== matched output ===\n")
            gdb.write(data.decode("utf-8", "replace") + "\n")
            gdb.execute("bt full")
            return True

        return False

FilteredWrite("write")

在一次 GDB 调试会话之后，我确认了这条警告是由 kwidgetsaddons 中的 kfontchooser.cpp 文件触发的。我还找到了触发这条警告的函数：

void KFontChooserPrivate::slotFeaturesChanged(const QString &features)
{
    m_selectedFont.clearFeatures();

    if (features.isEmpty()) {
        return;
    }

    const QStringList rawFeaturesList = features.split(QLatin1Char(','), Qt::SkipEmptyParts);
    for (const QString &feature : rawFeaturesList) {
        auto f = QStringView(feature).trimmed();
        if (f.isEmpty()) {
            continue;
        }
        QList<QStringView> parts = f.split(QStringLiteral("="), Qt::SkipEmptyParts);
        if (parts.length() == 2) {
            const auto tag = QFont::Tag::fromString(parts[0]);
            bool ok = false;
            const int number = parts[1].toInt(&ok);
            if (tag.has_value() && ok) {
                m_selectedFont.setFeature(tag.value(), number);
            }
        } else if (f.size() <= 4) {
            const auto tag = QFont::Tag::fromString(feature);
            if (tag.has_value()) {
                m_selectedFont.setFeature(tag.value(), 1);
            }
        }
    }

    Q_EMIT q->fontSelected(m_selectedFont);
}

我注意到，拆分后的结果已经被去掉了首尾空白：

auto f = QStringView(feature).trimmed();

但原始、未去空白的字符串却仍然被用作 tag：

const auto tag = QFont::Tag::fromString(feature);

这看起来是开发者写错了。要修复这个问题，我们只需要把未去空白的字符串改成去空白后的字符串：

const auto tag = QFont::Tag::fromString(f);

接下来，就该创建一个分支，把改动提交到该分支，并提交合并请求了。不过，由于我对 Git 的经验有限，我遇到了一个问题：

warning: redirecting to https://invent.kde.org/rebellfs/kwidgetsaddons.git/
Enumerating objects: 21973, done.
Counting objects: 100% (21973/21973), done.
Delta compression using up to 4 threads
Compressing objects: 100% (2790/2790), done.
Writing objects: 100% (21973/21973), 41.17 MiB | ... KiB/s, done.
Total 21973 (delta 13428), reused 21374 (delta 12884), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (13428/13428), done.
remote: Audit failure - Commit 046e4bb16e60b66070ee4a00c368ca6924db3a08 - Email address has an invalid domain : [kde@randomguy3.me.uk](mailto:kde@randomguy3.me.uk)
remote: Audit failure - Commit 046e4bb16e60b66070ee4a00c368ca6924db3a08 - Email address has an invalid domain : [kde@randomguy3.me.uk](mailto:kde@randomguy3.me.uk)
remote: Audit failure - Commit c8c7ab3d0e7ca825bbb01d58de005d4d589b12cc - Email address has an invalid domain : [kde@randomguy3.me.uk](mailto:kde@randomguy3.me.uk)
remote: Audit failure - Commit c8c7ab3d0e7ca825bbb01d58de005d4d589b12cc - Email address has an invalid domain : [kde@randomguy3.me.uk](mailto:kde@randomguy3.me.uk)
remote: Audit failure - Commit 62e5736a1f4afc2d24ef2c4d643a98bc60e6d6cd - Email address has an invalid domain : [kde@randomguy3.me.uk](mailto:kde@randomguy3.me.uk)
remote: Audit failure - Commit 62e5736a1f4afc2d24ef2c4d643a98bc60e6d6cd - Email address has an invalid domain : [kde@randomguy3.me.uk](mailto:kde@randomguy3.me.uk)
remote: Audit failure - Commit f317243c63620acec15a46c412502e73b9a04e2a - Email address has an invalid domain : [kde@randomguy3.me.uk](mailto:kde@randomguy3.me.uk)
remote: Audit failure - Commit f317243c63620acec15a46c412502e73b9a04e2a - Email address has an invalid domain : [kde@randomguy3.me.uk](mailto:kde@randomguy3.me.uk)
remote: Push declined - commits failed audit
remote: Should the audit failures above mention issues regarding your name, please ensure that your Git username has been set to your full name.
remote: Please see https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup for more details on ensuring Git has been fully configured.
remote: In the event that your full name has been set and is shown above as being rejected, please file a Sysadmin ticket at https://go.kde.org/systickets
To https://invent.kde.org/rebellfs/kwidgetsaddons
! [remote rejected]     work/rebel1725/fix523757 -> work/rebel1725/fix523757 (pre-receive hook declined)
error: failed to push some refs to 'https://invent.kde.org/rebellfs/kwidgetsaddons'

最后，因为这只是对单个文件的一个小改动，我还是通过浏览器提交了这项修改。

结论

今天，我完成了自己对自由软件社区的第一次贡献，也成为了一名全新的自由软件贡献者。今后，我希望能够贡献更多，不断磨练自己的技能，并且对社区和自由软件运动变得更加有帮助。

A/I 邮箱因垃圾邮件问题而弃用

rebel1725@tilde.club (Rebel Zhang) — Sun, 02 Aug 2026 12:26:22 +0800

由于我的 A/I 邮箱存在垃圾邮件问题，我已经启用了非常严格的垃圾邮件过滤策略，这会导致许多误判。以前我会不时查看垃圾邮件文件夹；但在过去几个月里，垃圾邮件问题变得越来越严重，也越来越难以区分正常邮件和垃圾邮件。

因此，我决定弃用我的 A/I 邮箱。今后请改用我的 Tilde.Club 电子邮箱与我联系，这个地址在过去几个月里已经是我的主邮箱。A/I 邮箱不会被注销，其 WKD 条目也仍会更新；不过，我无法保证我能够看到并回复发送到该邮箱的邮件。

AArch64 中的递归

rebel1725@tilde.club (Rebel Zhang) — Thu, 23 Jul 2026 17:57:11 +0800

基本模式

让我们从一个包含简单斐波那契计算函数的 C 程序开始。

#include <stdint.h>
#include <stdio.h>

uint64_t fibonacci(uint32_t index)
{
    if (index <= 1) return 1;
    else return fibonacci(index - 1) + fibonacci(index - 2);
}

int main()
{
    uint32_t i;
    scanf("%u", &i);
    printf("%lu", fibonacci(i));
    return 0;
}

编译它：

$ gcc fibo.c -o fibo0

默认情况下，GCC 根本不会做任何优化。打开你那闪亮的 iaito，进入 main 函数：

64: int main (int argc, char **argv, char **envp);
afv: vars(3:sp[0x4..0x20])
0x00000878      stp      x29,    x30,    [var_20h]!
0x0000087c      mov      x29,    sp
0x00000880      add      x0,     sp,     0x1c
0x00000884      mov      x1,     x0
0x00000888      adrp     x0,     0
0x0000088c      add      x0,     x0,     0x8d8
0x00000890      bl       sym.imp.__isoc23_scanf
0x00000894      ldr      w0,     [var_1ch]
0x00000898      bl       sym.fibonacci
0x0000089c      mov      x1,     x0
0x000008a0      adrp     x0,     0
0x000008a4      add      x0,     x0,     0x8e0 ; const char *format
0x000008a8      bl       sym.imp.printf ; int printf(const char *format)
0x000008ac      mov      w0,     0
0x000008b0      ldp      x29,    x30,    [sp],   0x20
0x000008b4      ret

这里你可以看到在 0x0000898 处调用了 sym.fibonacci。打开这个函数，看看它的图：

你会看到 sym.fibonacci 分别在 0x0000854 和 0x0000864 处调用了它自己。

如果你去掉了符号信息，那么你看不到 sym.fibonacci，但你仍然会在这里看到类似 bl fcn.00000828 的东西。总之，函数调用自身的这种模式表示递归。

优化

我们把 Fibonacci 函数换成阶乘函数：

#include <stdint.h>
#include <stdio.h>

uint64_t fact(uint32_t index)
{
    if (index <= 1) return 1;
    else return index * fact(index - 1);
}

int main()
{
    uint32_t i;
    scanf("%u", &i);
    printf("%lu", fact(i));
    return 0;
}

编译它：

$ gcc fact.c -o fact0

在 iaito 中打开后，你会得到一个调用 sym.fact 的 main 函数：

64: int main (int argc, char **argv, char **envp);
afv: vars(3:sp[0x4..0x20])
0x0000086c      stp      x29,    x30,    [var_20h]!
0x00000870      mov      x29,    sp
0x00000874      add      x0,     sp,     0x1c
0x00000878      mov      x1,     x0
0x0000087c      adrp     x0,     0
0x00000880      add      x0,     x0,     0x8d0 ; "%u"
0x00000884      bl       sym.imp.__isoc23_scanf
0x00000888      ldr      w0,     [var_1ch]
0x0000088c      bl       sym.fact ; sym.fact(0x0)
0x00000890      mov      x1,     x0
0x00000894      adrp     x0,     0
0x00000898      add      x0,     x0,     0x8d8 ; const char *format ; "%lu"
0x0000089c      bl       sym.imp.printf ; int printf(const char *format)
; int printf("%lu")
0x000008a0      mov      w0,     0
0x000008a4      ldp      x29,    x30,    [sp],   0x20
0x000008a8      ret

被调用的 sym.fact 函数的反汇编如下：

68: fact (int64_t arg1);
`- args(x0) vars(4:sp[0x4..0x30])
0x00000828      stp      x29,    x30,    [var_30h]!
0x0000082c      mov      x29,    sp
0x00000830      str      x19,    [var_10h]
0x00000834      str      w0,     [var_2ch] ; arg1
0x00000838      ldr      w0,     [var_2ch]
0x0000083c      cmp      w0,     1
0x00000840      b.hi     0x84c ; unlikely
0x00000844      mov      x0,     1
0x00000848      b        0x860
0x0000084c      ldr      w19,    [var_2ch]
0x00000850      ldr      w0,     [var_2ch]
0x00000854      sub      w0,     w0,     1
0x00000858      bl       sym.fact ; sym.fact(-1)
0x0000085c      mul      x0,     x19,    x0
0x00000860      ldr      x19,    [var_10h]
0x00000864      ldp      x29,    x30,    [sp],   0x30
0x00000868      ret

以及它的图：

那么，如果我们打开优化会怎样？试试看：

$ gcc fact.c -O2 -o fact2

在 iaito 中打开并检查 main 函数。你会看到：

调用 sym.fact 的那条指令不见了。取而代之的是，main 函数内部出现了一个循环来完成工作。

回到包含 Fibonacci 函数的 C 代码，在开启优化的情况下重新编译，然后检查 main 函数：

  ;-- section..text:
60: int main (int argc, char **argv, char **envp);
afv: vars(3:sp[0x4..0x20])
0x00000700      stp      x29,    x30,    [var_20h]! ; [12] -r-x section size 1176 named .text
0x00000704      adrp     x0,     0
0x00000708      add      x0,     x0,     0xbb8 ; "%u"
0x0000070c      mov      x29,    sp
0x00000710      add      x1,     sp,     0x1c
0x00000714      bl       sym.imp.__isoc23_scanf
0x00000718      ldr      w0,     [var_1ch]
0x0000071c      bl       sym.fibonacci ; sym.fibonacci(0x0, 0x177ffc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
0x00000720      mov      x1,     x0
0x00000724      adrp     x0,     0
0x00000728      add      x0,     x0,     0xbc0 ; const char *format ; "%lu"
0x0000072c      bl       sym.imp.printf ; int printf(const char *format)
0x00000730      mov      w0,     0
0x00000734      ldp      x29,    x30,    [sp],   0x20
0x00000738      ret

调用 sym.fibonacci 的指令仍然存在。

打开 sym.fibonacci 的反汇编，你会体会到编译器有多么“疯狂”：

792: fibonacci (uint32_t arg1, int64_t arg_60h, int64_t arg_70h, int64_t arg_80h, int64_t arg_88h, int64_t arg_90h, int64_t arg_98h, int64_t arg_a0h, int64_t arg_a8h);
`- args(x0, sp[0x60..0xa8]) vars(27:sp[0x4..0xb0])
0x00000880      sub      w6,     w0,     1 ; arg1
0x00000884      mov      x1,     0
0x00000888      cmp      w0,     1 ; arg1
0x0000088c      b.ls     0xb68 ; likely
0x00000890      cmp      w6,     1
0x00000894      b.eq     0xb70 ; unlikely
0x00000898      sub      w10,    w6,     1
0x0000089c      mov      x3,     0
0x000008a0      mov      w7,     w10
0x000008a4      cmp      w7,     1
0x000008a8      b.eq     0xb4c ; unlikely
0x000008ac      sub      w11,    w7,     1
0x000008b0      mov      x4,     0
0x000008b4      mov      w8,     w11
0x000008b8      cmp      w8,     1
0x000008bc      b.eq     0xb30 ; unlikely
0x000008c0      sub      w12,    w8,     1
0x000008c4      mov      x5,     0
0x000008c8      mov      w9,     w12
0x000008cc      cmp      w12,    1
0x000008d0      b.eq     0xa98 ; unlikely
0x000008d4      stp      x29,    x30,    [var_b0h]!
0x000008d8      mov      x29,    sp
0x000008dc      stp      x19,    x20,    [var_10h]
0x000008e0      stp      x21,    x22,    [var_20h]
0x000008e4      stp      x23,    x24,    [var_30h]
0x000008e8      stp      x25,    x26,    [var_40h]
0x000008ec      stp      x27,    x28,    [var_50h]
0x000008f0      sub      w13,    w9,     1
0x000008f4      mov      w25,    w13
0x000008f8      mov      x20,    0
0x000008fc      cmp      w25,    1
0x00000900      b.eq     0xa90 ; unlikely
0x00000904      sub      w27,    w25,    1
0x00000908      mov      x19,    0
0x0000090c      mov      w26,    w27
0x00000910      cmp      w26,    1
0x00000914      b.eq     0x9fc ; unlikely
0x00000918      sub      w28,    w26,    1
0x0000091c      mov      x22,    0
0x00000920      mov      w2,     w28
0x00000924      cmp      w2,     1
0x00000928      b.eq     0x9dc ; unlikely
0x0000092c      sub      w15,    w2,     1
0x00000930      mov      x21,    0
0x00000934      mov      w24,    w15
0x00000938      cmp      w24,    1
0x0000093c      b.eq     0x9bc ; unlikely
0x00000940      mov      w23,    w24
0x00000944      mov      x14,    0
0x00000948      sub      w0,     w23,    1
0x0000094c      stp      x1,     x3,     [arg_60h]
0x00000950      sub      w23,    w23,    2
0x00000954      stp      x4,     x5,     [arg_70h]
0x00000958      stp      w6,     w10,    [arg_80h]
0x0000095c      str      x14,    [arg_88h]
0x00000960      stp      w7,     w11,    [arg_90h]
0x00000964      stp      w8,     w12,    [arg_98h]
0x00000968      stp      w9,     w13,    [arg_a0h]
0x0000096c      stp      w2,     w15,    [arg_a8h]
0x00000970      bl       sym.fibonacci ; sym.fibonacci(0x1d001efffffff8, 0x0, 0xfffffffa, 0x0, 0x0, 0x0, 0x0, -1, 0x0)
0x00000974      ldr      x14,    [arg_88h]
0x00000978      cmp      w23,    1
0x0000097c      ldp      x1,     x3,     [arg_60h]
0x00000980      add      x14,    x14,    x0
0x00000984      ldp      x4,     x5,     [arg_70h]
0x00000988      ldp      w6,     w10,    [arg_80h]
0x0000098c      ldp      w7,     w11,    [arg_90h]
0x00000990      ldp      w8,     w12,    [arg_98h]
0x00000994      ldp      w9,     w13,    [arg_a0h]
0x00000998      ldp      w2,     w15,    [arg_a8h]
0x0000099c      b.hi     0x948 ; likely
0x000009a0      add      x21,    x21,    1
0x000009a4      add      x21,    x21,    x14
0x000009a8      cmp      w24,    2
0x000009ac      b.eq     0x9c0 ; unlikely
0x000009b0      sub      w24,    w24,    2
0x000009b4      cmp      w24,    1
0x000009b8      b.ne     0x940 ; likely
0x000009bc      add      x21,    x21,    1
0x000009c0      add      x22,    x22,    1
0x000009c4      sub      w2,     w2,     2
0x000009c8      add      x22,    x22,    x21
0x000009cc      cmp      w15,    1
0x000009d0      b.eq     0x9e0 ; unlikely
0x000009d4      cmp      w2,     1
0x000009d8      b.ne     0x92c ; likely
0x000009dc      add      x22,    x22,    1
0x000009e0      add      x19,    x19,    1
0x000009e4      sub      w26,    w26,    2
0x000009e8      add      x19,    x19,    x22
0x000009ec      cmp      w28,    1
0x000009f0      b.eq     0xa00 ; unlikely
0x000009f4      cmp      w26,    1
0x000009f8      b.ne     0x918 ; likely
0x000009fc      add      x19,    x19,    1
0x00000a00      add      x20,    x20,    1
0x00000a04      sub      w25,    w25,    2
0x00000a08      add      x20,    x20,    x19
0x00000a0c      cmp      w27,    1
0x00000a10      b.ne     0x8fc ; likely
0x00000a14      add      x5,     x5,     1
0x00000a18      sub      w9,     w9,     2
0x00000a1c      add      x5,     x5,     x20
0x00000a20      cmp      w13,    1
0x00000a24      b.eq     0xa34 ; unlikely
0x00000a28      cmp      w9,     1
0x00000a2c      b.ne     0x8f0 ; likely
0x00000a30      add      x5,     x5,     1
0x00000a34      add      x4,     x4,     1
0x00000a38      sub      w8,     w8,     2
0x00000a3c      add      x4,     x4,     x5
0x00000a40      cmp      w12,    1
0x00000a44      b.eq     0xa64 ; unlikely
0x00000a48      cmp      w8,     1
0x00000a4c      b.eq     0xa60 ; unlikely
0x00000a50      sub      w12,    w8,     1
0x00000a54      mov      x5,     0
0x00000a58      mov      w9,     w12
0x00000a5c      b        0xa28
0x00000a60      add      x4,     x4,     1
0x00000a64      add      x3,     x3,     1
0x00000a68      sub      w7,     w7,     2
0x00000a6c      add      x3,     x3,     x4
0x00000a70      cmp      w11,    1
0x00000a74      b.eq     0xae4 ; unlikely
0x00000a78      cmp      w7,     1
0x00000a7c      b.eq     0xae0 ; unlikely
0x00000a80      sub      w11,    w7,     1
0x00000a84      mov      x4,     0
0x00000a88      mov      w8,     w11
0x00000a8c      b        0xa48
0x00000a90      add      x20,    x20,    1
0x00000a94      b        0xa14
0x00000a98      add      x5,     x5,     1
0x00000a9c      add      x4,     x4,     1
0x00000aa0      add      x4,     x4,     x5
0x00000aa4      sub      w8,     w8,     2
0x00000aac      cmp      w12,    1
0x00000ab0      b.ne     0x8b8 ; likely
0x00000ab4      add      x3,     x3,     1
0x00000ab8      sub      w7,     w7,     2
0x00000abc      add      x3,     x3,     x4
0x00000ac0      cmp      w11,    1
0x00000ac4      b.ne     0x8a4 ; likely
0x00000ac8      add      x0,     x1,     1
0x00000acc      sub      w6,     w6,     2
0x00000ad0      add      x1,     x0,     x3
0x00000ad4      cmp      w10,    1
0x00000ad8      b.ne     0x890 ; likely
0x00000adc      add      x0,     x1,     1
0x00000ae0      add      x3,     x3,     1
0x00000ae4      add      x0,     x1,     1
0x00000ae8      sub      w6,     w6,     2
0x00000aec      add      x1,     x0,     x3
0x00000af0      cmp      w10,     1
0x00000af4      b.eq     0xb78 ; unlikely
0x00000af8      cmp      w6,     1
0x00000afc      b.eq     0xb10 ; unlikely
0x00000b00      sub      w10,    w6,     1
0x00000b04      mov      x3,     0
0x00000b08      mov      w7,     w10
0x00000b0c      b        0xa78
0x00000b10      ldp      x19,    x20,    [var_10h]
0x00000b14      add      x0,     x1,     2
0x00000b18      ldp      x21,    x22,    [var_20h]
0x00000b1c      ldp      x23,    x24,    [var_30h]
0x00000b20      ldp      x25,    x26,    [var_40h]
0x00000b24      ldp      x27,    x28,    [var_50h]
0x00000b28      ldp      x29,    x30,    [sp],   0xb0
0x00000b2c      ret
0x00000b30      add      x4,     x4,     1
0x00000b34      add      x3,     x3,     1
0x00000b38      add      x3,     x3,     x4
0x00000b3c      sub      w7,     w7,     2
0x00000b40      cmp      w11,    1
0x00000b44      b.ne     0x8a4 ; likely
0x00000b48      b        0xac4
0x00000b4c      add      x3,     x3,     1
0x00000b50      add      x0,     x1,     1
0x00000b54      add      x1,     x0,     x3
0x00000b58      sub      w6,     w6,     2
0x00000b5c      cmp      w10,     1
0x00000b60      b.ne     0x890 ; likely
0x00000b64      b        0xad8
0x00000b68      mov      x0,     1
0x00000b6c      ret
0x00000b70      add      x0,     x1,     2
0x00000b74      ret
0x00000b78      ldp      x19,    x20,    [var_10h]
0x00000b7c      add      x0,     x1,     1
0x00000b80      ldp      x21,    x22,    [var_20h]
0x00000b84      ldp      x23,    x24,    [var_30h]
0x00000b88      ldp      x25,    x26,    [var_40h]
0x00000b8c      ldp      x27,    x28,    [var_50h]
0x00000b90      ldp      x29,    x30,    [sp],   0xb0 ; 0x178000
0x00000b94      ret

不过，你仍然可以从 0x00000970 处的自调用看出这是递归。

这两者为什么不同？在 fact() 函数中，调用关系是一条单一的线性链：

这样一条线性的调用链可以等价为一个循环。因此，编译器会将其优化，以节省栈空间。

递归与循环等价的一个典型例子是尾递归，也就是最后一个操作是调用自身。例如：

void f(unsigned int x, int *a)
{
    if (x == 0) return;
    else
    {
        *a += x;
        return f(x - 1, a);
    }
}

这种递归已经被证明可以转换为等价的循环，因此编译器会对其进行优化。上面的 fact() 示例虽然不是尾递归，但它仍然是线性的，编译器识别出了这个模式，所以也把它优化了。

不过，fibonacci() 不是这种情况：

它的调用关系不是线性的，而是一棵树。因此，不可能把它转换成循环——编译器也就保留了递归模式。

致顾悦萱一封公开信

rebel1725@tilde.club (Rebel Zhang) — Fri, 17 Jul 2026 00:30:47 +0800

你好啊，是我，Rebel。你曾深爱过，也深深爱着你的那个男孩儿。不知你现在怎么样，也不知道你是否最终会看到这封信。不过即便如此，把我心中的一些想法用文字写下来。

不知不觉，从那件事情发生到现在，已经过去十四天了。其实退网的这段时间，我一直在忙于琐事。但即便如此，我依然偶尔有时间想到我们过去的点点滴滴。你曾说过我对于自由软件的热爱打动了你，但反过来你的热情也同样打动了我。我们都有充满着伤痛和坎坷的过去，都热爱着自由软件和自由软件运动，都志在逆向工程，都希望为 postmarketOS 作出贡献——我们真的有很多共同点。

那条受到自由软件的保护、端到端加密的信道里，是我们感情的桥梁。我们可以在这里交流任何想说的内容，无论是技术还是生活，从编程语言，到各种自由软件技术，再到日常生活中的酸甜苦辣。

我能感受到，你对我很好、很体贴，也很关心我。你愿意包容我的缺点，愿意理解我曾经犯下来的错误，你亲口对我说，你愿意站在我这一边。这让我很感动，真的真的很感动。

我能感受到，我们的灵魂有着深深的共鸣。我也明白了，最伟大的爱情，并非二人之间望向彼此，而是共同望向同一个方向。你是我真正的、发自内心深处的爱着的那个人，因为，在我心中，你和逆向工程、radare2、iaito、GDB，以及我们所学习的各种自由软件技术，还有我们共同的自由软件、自由社会的理想，已经深深捆绑在一起了。我对你的爱便是对于自由软件的爱，反之亦然——我已经实现了对你的爱和对于自由软件的爱的统一。

在这个充满着审查和监视的世界，在这个专有软件的不公正性日益凸显的世界，在这个自由软件更加重要的世界，我们依然为共同的理想奋斗着；依然为我们、我们身边的人，乃至于整个社区、全体无产阶级计算机用户甚至全人类共同的自由软件、自由社会而奋斗。

也感谢我曾遇见你。虽然我们的关系仅仅维系了不到四个月就戛然而止（是的，甚至比我和 Zumfy/Future 还要短上一个月左右），但是你让我对于爱情这件事对我意味着什么，有了最初步的、基于实践的认识。

谢谢你。

x86_64 中的除法、模运算和冒泡排序

rebel1725@tilde.club (Rebel Zhang) — Wed, 08 Jul 2026 17:46:33 +0800

用高级语言（例如 C）写出来的算法，在查看源代码时会显得非常直白。然而，编译器会把它们在汇编层面转换成一些相当神秘的模式。为了提升我们的逆向工程能力，我们需要学习这些模式，这样才能快速识别它们。这篇博客会列举一些例子，它们都是我今天在解一道 CTF 题时遇到的。

整数之间的有符号除法

先看这段代码：

#include <stdio.h>

int div(int a)
{
    return a / 42;
}

int main()
{
    int a;
    scanf("%d", &a);
    a = div(a);
    printf("%d", a);
    return 0;
}

把它编译一下，然后打开你心爱的 iaito 或 radare2，看看汇编。我们不需要关心 main()，所以直接进入 sym.div，就能看到类似这样的内容：

36: div (int64_t arg1);
`- args(rdi) vars(1:sp[0xc..0xc])
0x00001149      push     rbp
0x0000114a      mov      rbp,    rsp
0x0000114d      mov      dword [var_4h],  edi ; arg1
0x00001150      mov      eax,    dword [var_4h]
0x00001153      movsxd   rdx,    eax
0x00001156      imul     rdx,    rdx,    0x30c30c31
0x0000115d      shr      rdx,    0x20
0x00001161      sar      edx,    3
0x00001164      sar      eax,    0x1f
0x00001167      sub      edx,    eax
0x00001169      mov      eax,    edx
0x0000116b      pop      rbp
0x0000116c      ret

这里看不到 idiv 指令。相反，我们能看到 0x00001156 处有一条 imul 指令，后面跟着一条 shr 指令和一条 sar 指令。之后，结果会出现在 edx 寄存器里。

但如果我们换一个数字，会发生什么？试试看。编译下面这段：

#include <stdio.h>

int div(int a)
{
    return a / 6;
}

int main()
{
    int a;
    scanf("%d", &a);
    a = div(a);
    printf("%d", a);
    return 0;
}

我们会得到一段类似的反汇编：

33: div (int64_t arg1);
`- args(rdi) vars(1:sp[0xc..0xc])
0x00001149      push     rbp
0x0000114a      mov      rbp,    rsp
0x0000114d      mov      dword [var_4h],  edi ; arg1
0x00001150      mov      eax,    dword [var_4h]
0x00001153      movsxd   rdx,    eax
0x00001156      imul     rdx,    rdx,    0x2aaaaaab
0x0000115d      shr      rdx,    0x20
0x00001161      sar      eax,    0x1f
0x00001164      sub      edx,    eax
0x00001166      mov      eax,    edx
0x00001168      pop      rbp
0x00001169      ret

如果我们使用负数，会发生什么？把 6 换成 -7，我们会得到类似的结果：

36: div (int64_t arg1);
`- args(rdi) vars(1:sp[0xc..0xc])
0x00001149      push     rbp
0x0000114a      mov      rbp,    rsp
0x0000114d      mov      dword [var_4h],  edi ; arg1
0x00001150      mov      eax,    dword [var_4h]
0x00001153      movsxd   rdx,    eax
0x00001156      imul     rdx,    rdx,    0xffffffff92492493
0x0000115d      shr      rdx,    0x20
0x00001161      add      edx,    eax
0x00001163      sar      edx,    2
0x00001166      sar      eax,    0x1f
0x00001169      sub      eax,    edx
0x0000116b      pop      rbp
0x0000116c      ret

如果我们不使用常量，会发生什么？编译下面这段：

#include <stdio.h>

int div(int a, int b)
{
    return a / b;
}

int main()
{
    int a, b;
    scanf("%d %d", &a, &b);
    a = div(a, b);
    printf("%d", a);
    return 0;
}

之后，我们终于会看到不同的东西：

19: div (int64_t arg1, signed int64_t arg2);
`- args(rdi, rsi) vars(2:sp[0xc..0x10])
0x00001149      push     rbp
0x0000114a      mov      rbp,    rsp
0x0000114d      mov      dword [var_4h],  edi ; arg1
0x00001150      mov      dword [var_8h],  esi ; arg2
0x00001153      mov      eax,    dword [var_4h]
0x00001156      cdq
0x00001157      idiv     dword [var_8h]
0x0000115a      pop      rbp
0x0000115b      ret

x86_64 CPU 确实支持除法，但代价很高。因此，如果除数已经以常量形式给出，编译器就会在编译时替我们做这种优化。它会根据除数计算出一个魔数乘数，并把除法转换成乘法和位移的组合。有一篇论文对这个算法作了进一步解释。

不过，如果这个常量只在运行时才知道，这种优化就帮不上忙了，因此它会直接使用除法指令。

取模运算

现在编译这段：

#include <stdio.h>

int mymod(int a)
{
    return a % 42;
}

int main()
{
    int a;
    scanf("%d", &a);
    a = mymod(a);
    printf("%d", a);
    return 0;
}

我们会得到 mymod() 的反汇编：

45: mymod (int64_t arg1);
`- args(rdi) vars(1:sp[0xc..0xc])
0x00001149      push     rbp
0x0000114a      mov      rbp,    rsp
0x0000114d      mov      dword [var_4h],  edi ; arg1
0x00001150      mov      eax,    dword [var_4h]
0x00001153      movsxd   rdx,    eax
0x00001156      imul     rdx,    rdx,    0x30c30c31
0x0000115d      shr      rdx,    0x20
0x00001161      sar      edx,    3
0x00001164      mov      ecx,    eax
0x00001166      sar      ecx,    0x1f
0x00001169      sub      edx,    ecx
0x0000116b      imul     ecx,    edx,    0x2a
0x0000116e      sub      eax,    ecx
0x00001170      mov      edx,    eax
0x00001172      mov      eax,    edx
0x00001174      pop      rbp
0x00001175      ret

从 0x00001150 到 0x00001161 的指令使用了上面提到的魔数乘数来实现除法。然后它会把被除数复制一份到 ecx，再对它进行 31 位算术右移。如果被除数是非负数，ecx 就是 0；否则，它就是 -1。

这样做是为了从被除数中计算出一个 bias，因为除法总是向零截断。我们用商来计算取模：对于正数，模 = 被除数 - 除数 * 商；对于负数，模 = 被除数 - 除数 * （商 + 1）。

冒泡排序

最后编译这段：

#include <stdio.h>

void bubble(int *arr, int n)
{
    for (int i1 = 0; i1 < n - 1; i1++)
    {
        for (int i2 = 0; i1 + i2 < n - 1; i2++)
        {
            if (arr[i1] > arr[i2])
            {
                int tmp = arr[i1];
                arr[i1] = arr[i2];
                arr[i2] = tmp;
            }
        }
    }
}

int main()
{
    int a[42];
    for (int i1 = 0; i1 < 42; i1++)
        a[i1] = 42 - i1;
    bubble(a, 42);
    for (int i1 = 0; i1 < 42; i1++)
        printf("%d", a[i1]);
    return 0;
}

这次看看 iaito 生成的 sym.bubble 图：

我们可以看到，0x00001144 处设置了一个计数器。0x00001209 这个块里有一次比较。如果计数器还没有达到阈值，就会继续执行。0x00001150 处又设置了一个计数器。0x0000115c 这个块里会比较两个相邻的数字。如果前者更大，就会在 0x0000118c 这个块里执行交换。

结论

这只是逆向工程过程中可能遇到的几种模式示例。随着我们做得越来越多，我们会积累越来越多的经验，也就能够更快地识别反汇编中的更多模式。

告别——也许我们终有一天再见？

rebel1725@tilde.club (Rebel Zhang) — Sun, 05 Jul 2026 16:37:56 +0800

由于我目前无法透露的某些原因，我将无限期地（也许是永久地？）淡出社区。在这篇博客文章中，我想澄清几点：

我的即时通讯账号，包括但不限于 XMPP、Matrix、SimpleX 和 Delta Chat，将很快不再活跃。不过，至少目前，它们不会被停用，这些账号上的信任在可预见的未来也不会失效。
社交账号，包括但不限于 Mastodon，将继续保持活跃。
我的主 OpenPGP 公钥（指纹为 696A423E9993D727706AA733BCD5DC5659C7FB50）至少目前不会被撤销，并将继续更新。不过，我的备用 OpenPGP 公钥（指纹为 7083EAFFF75321FF9634ABCD98313A47362B498B）可能会被撤销；如果是这样，我会将撤销信息上传到 OpenPGP 密钥服务器。
我的电子邮件地址 rebel1725@tilde.club 将继续使用。你可以通过这个电子邮件地址联系我。
我将继续担任 FSCS（自由软件中文网, https://freeswzhcn.codeberg.page/）的首席官方贡献者，其基础设施也将继续运行在我的服务器上。不过，其关联项目 FSCC（自由软件中文社区, https://fscc_next.codeberg.page/）的管理权将移交给 Aurora Garcia（0x28EC1231FACA465A, https://aurorag132.codeberg.page/）。此外，XMPP Together Committee（https://xmpptogether.codeberg.page/）主席一职，以及由我管理的该委员会频道的管理员权限，也将移交给 Aurora Garcia。
无论是现代风格网站还是复古风格网站都不会关闭，我也会继续在这个博客上发文。此外，关于我的任何更新也都会发布在博客上。

万事终有尽头。愿没有我的日子里，你们的生活充满快乐与喜悦。

我的 Eepsite 已重新上线

rebel1725@tilde.club (Rebel Zhang) — Wed, 10 Jun 2026 13:57:10 +0800

我以前把我的 eepsite 托管在家里的服务器上，但大约两周前，出于安全考虑，我停止了托管。现在我找到了一种在 ~vern 上托管它的方法，所以它又重新上线了。

欢迎访问 rebel1725.i2p。

使用 Net Qube 将流量路由到 SOCKS 代理

rebel1725@tilde.club (Rebel Zhang) — Fri, 05 Jun 2026 00:08:03 +0800

免责声明：我是在一切“似乎”都正常工作之后才写下这份指南的。对于流量泄漏或其他意外问题，我不承担责任。

本文说明如何使用 net qube，通过特定 qube 将流量路由到 SOCKS 代理。

第 1 步：安装所需软件包

你需要 screen 和 redsocks。


# apt install screen redsocks

第 2 步：创建一个 net qube

请在你的 Qube Manager 中完成这一步。

第 3 步：配置 `redsocks`

在新的 net qube 中创建 /rw/config/redsocks.conf：


base {
log_info = on;
log_debug = on;
log = stderr;
daemon = on;
redirector = iptables;
}

redsocks {
local_ip = 0.0.0.0;
local_port = 12345;

ip = <changeme>;
port = <changeme>;
type = <changeme>;
login = "<changeme>";
password = "<changeme>";
}

第 4 步：配置自动启动

将以下内容添加到新 net qube 中的 /rw/config/rc.local：


systemctl stop redsocks

nft add table ip nat 2>/dev/null || true
nft 'add chain ip nat prerouting { type nat hook prerouting priority -100; policy accept; }' 2>/dev/null || true

nft add set ip nat bypass4 '{ type ipv4_addr; flags interval; elements = { 
0.0.0.0/8, 
10.0.0.0/8, 
100.64.0.0/10, 
127.0.0.0/8, 
169.254.0.0/16, 
172.16.0.0/12, 
192.168.0.0/16, 
224.0.0.0/4, 
240.0.0.0/4 
} }' 2>/dev/null || true

nft add rule ip nat prerouting ip daddr @bypass4 accept
nft add rule ip nat prerouting meta l4proto tcp redirect to :12345
nft add rule ip qubes custom-input iifgroup 2 tcp dport 12345 ct state new,established,related counter accept

cp /rw/config/redsocks.conf /etc/redsocks.conf
systemctl start redsocks

第 5 步：重启并配置

重启该 net qube，然后把你希望通过这个代理转发流量的那些 qube 的 net qube 设置为这个 net qube。

一切就绪，祝你使用愉快 :-)

问题：有时 redsocks 会收到 SIGABRT 信号并崩溃。解决方法：运行 systemctl start redsocks 将其重新启动。

挑战-响应中的一个严重安全问题

rebel1725@tilde.club (Rebel Zhang) — Thu, 28 May 2026 00:47:56 +0800

挑战-响应的一种做法是，把一个随机字符串（nonce）发送给需要验证身份的人，并让对方使用自己的私钥对该字符串进行签名。然而，这会带来一个非常严重的安全问题。

例如，Alice 想要验证 Bob。但 Mallory 插在他们中间。于是会发生下面的事情：

Alice 将挑战发送给被 Mallory 冒充的 ‘Bob’。
Mallory 冒充 Alice，将该挑战转发给 Bob，并请求返回响应。
Bob 把响应发回，然后 Mallory 再把响应转发回去。

在这种情况下，Mallory 已经成功向 Alice 冒充了 Bob，现在就可以进行 MITM 攻击了。

解决办法不是只把随机字符串当作挑战。一个好的挑战至少应包含以下内容：

验证者和被验证者的信任锚的标识信息（例如 OpenPGP 指纹）；
通道的标识信息（例如，面对面验证时的地点；在 XMPP 上验证时的 JID 以及 OMEMO 指纹；在 Matrix 上验证时双方的 Matrix ID 和房间）；
时间戳；
nonce，也就是随机字符串。

换句话说，挑战应当把验证者和被验证者的身份、已认证的通道或会话上下文、用于保证新鲜度的时间戳，以及 nonce 绑定在一起。验证者必须将已签名的身份声明与已认证的传输元数据进行比对。

在这种情况下，Mallory 就必须篡改通道上下文来欺骗 Bob（否则 Bob 会立刻识别出这个有问题的挑战并拒绝响应），而这样一来，由于挑战已被篡改，Alice 在验证时就会发现响应无效。

为了获得更强的安全性，请彼此相互验证。

使用 GDB 和 Iaito/Radare2 的逆向工程示例

rebel1725@tilde.club (Rebel Zhang) — Wed, 27 May 2026 23:56:34 +0800

过去几周里，我一直在学习逆向工程，并且写了一篇博客文章来分享我的第一次体验。最近，我又深入了一些，正在用静态分析和动态分析相结合的方式解决一个 CTF 题目，而我觉得这正是进一步解释逆向工程的一个很好的例子。

我之前原本打算写一篇关于使用 GDB 进行动态分析的文章。不过，我发现这个题目同样非常适合用来解释 GDB。为了解出这个题目，我还会使用另一个工具，iaito，它是 radare2 的图形前端。

题目

cIMG 可以说是一种图像格式，用来在终端中表示由不同颜色字符组成的图像。它由以下部分构成：

魔数，也就是 cIMG；
版本号；
宽度和高度；
数据，每个像素都包含 R、G、B 和 ASCII 字符。

这个题目要求你向一个可执行程序提供一个 cIMG 文件，只有当 cIMG 满足某些条件时，它才会给出 flag。

源代码

在这里获取题目的source。这份源代码看起来使用的是 BSD 2-Clause 许可证。

使用 GCC 编译它：

$ gcc -O3 challenge.c -o challenge

打开 Python 并创建一个示例 cIMG 文件：

$ python3
Python 3.13.5 (Jun 25 2025, 18:55:22) [GCC 14.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> with open("example.cimg", "wb") as file:
...     file.write(b"cIMG\x02\0\x0a\x0a")
...     file.write(b"\x50"*(10*10*4))
...     
8
400

使用题目的二进制程序打开这个示例 cIMG 文件：

user@learnaarch64asm:~$ ./challenge ./example.cimg 
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP

这个文件会输出内容，但不会给出 flag。

静态分析

我们需要构造一个能 给出 flag 的 cIMG 文件。先做静态分析。

在 iaito 中打开文件。执行 aaa 分析，并打开 main 函数的图形视图。你会得到：

我们可以看到在 0x00000cac 处读取文件头，在 0x00000cc4 处检查魔数，在 0x00000cd0 处检查版本号，在 0x00000ce0 处读取宽度和高度。然后它使用 malloc 为图像数据分配一块内存，并把数据读入其中。

魔数是 cIMG，换成十六进制就是 63 49 4d 47；版本号是一个 32 位小端整数；高度和宽度都是 8 位整数。

flag 条件

我们直接看函数结尾。显然，sym.win 是会给出 flag 的函数。它在 0x00000e8c 被调用，而这一步是在 0x00000e58 处的一次检查之后执行的。这项检查要求 w19 不能为零。

篡改控制流

该启动 GDB 了。

$ gdb --args ./challenge ./example.cimg 
GNU gdb (Debian 16.3-1) 16.3
Copyright (C) 2024 Free Software Foundation, Inc.
License GPLv3+ or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Type "show copying" and "show warranty" for details.
This GDB was configured as "aarch64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<https://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
    <http://www.gnu.org/software/gdb/documentation/>.

For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from ./challenge...
(No debugging symbols found in ./challenge)

在 main 函数处打断点并启动程序：

(gdb) break *main
Breakpoint 1 at 0xc44
(gdb) run
Starting program: /home/user/challenge ./example.cimg
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/aarch64-linux-gnu/libthread_db.so.1".

Breakpoint 1, 0x0000aaaaaaaa0c44 in main ()

我们注意到 GDB 的数据地址有一个 0xaaaaaaaa0000 的偏移。

在 flag 条件检查之前打断点，然后继续执行：

(gdb) break *0x0000aaaaaaaa0e58
Breakpoint 2 at 0xaaaaaaaa0e58
(gdb) continue
Continuing.
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP

Breakpoint 2, 0x0000aaaaaaaa0e58 in main ()

修改寄存器 w19 的内容并继续执行：

(gdb) set $w19 = 1
(gdb) continue

然后这个可执行程序就会给出 flag。至此任务完成，祝你有美好的一天 :-p

开玩笑的。如果我们真的这样结束这个题目，逆向工程的乐趣就没了。让我们继续深入。

数据检查

回到 iaito。点击图中的 w19。这会在图里的所有指令中高亮该寄存器。向前回溯图形，寻找线索。

我们可以在图中看到一些对 sym.imp.memcmp 的调用。

memcmp 是 C 标准库中的一个函数，声明在 <string.h> 中，它会逐字节比较两块内存：

int memcmp(const void *ptr1, const void *ptr2, size_t n);

ptr1 和 ptr2 分别指向那两块内存，而 n 指定要比较的字节数。如果两块内存完全相同，该函数返回 0；否则返回一个非零值。

这里有四次 memcmp 调用。每次调用后面都跟着 cmp w0, 0。除了第一次调用之外，cmp 后面还有 cset w0, eq 和 and w19, w19, w0。我们可以得出结论：如果 memcmp 发现差异，w19 就会被清零，因为那时 w0 会变成零。因此我们猜测，需要让四对内存块完全相同。

x0 和 x1 是要比较的两个地址。x2 包含大小；mov x2, 0x18 告诉我们大小是 24 字节。

再次打开 GDB，并在第一次 memcmp 之前检查内存：

(gdb) break *0x0000aaaaaaaa0e78
Breakpoint 1 at 0xaaaaaaaa0e78
(gdb) run
Starting program: /home/user/challenge ./example.cimg
[Thread debugging using libthread_db library "/lib/aarch64-linux-gnu/libthread_db.so.1].
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP
PPPPPPPPPP

Breakpoint 1, 0x0000aaaaaaaa0e78 in main ()
(gdb) info registers x0 x1
x0             0xaaaaaaac12a0      187649984565920
x1             0xaaaaaaac00c0      187649984561344
(gdb) x/24xb $x0
0xaaaaaaac12a0: 0x1b    0x5b    0x33    0x38    0x3b    0x32    0x3b    0x30
0xaaaaaaac12a8: 0x38    0x30    0x3b    0x30    0x38    0x30    0x3b    0x30
0xaaaaaaac12b0: 0x38    0x30    0x6d    0x50    0x1b    0x5b    0x30    0x6d
(gdb) x/24xb $x1
0xaaaaaaac00c0 <desired_output>:        0x1b    0x5b    0x33    0x38    0x3b   0x32     0x3b    0x32
0xaaaaaaac00c8 <desired_output+8>:      0x33    0x31    0x3b    0x30    0x31   0x37     0x3b    0x31
0xaaaaaaac00d0 <desired_output+16>:     0x33    0x30    0x6d    0x63    0x1b   0x5b     0x30    0x6d

随机字节。我看不出它们是什么意思。

回到 iaito。第一块内存是从 x22 载入的，而 x22 又是从地址 var_48h 载入的。afv 告诉我们它距离 sp 是 0x48：

[0x00000e70]> afv
arg signed int argc @ x0
arg char ** s @ x1
var int64_t var_50h @ sp+0x0
var int64_t var_50h_2 @ sp+0x8
var int64_t var_10h @ sp+0x10
var int64_t var_10h_2 @ sp+0x18
var int64_t var_20h @ sp+0x20
var int64_t var_20h_2 @ sp+0x28
var void * buf @ sp+0x38
var int64_t var_3ch @ sp+0x3c
var int64_t var_3eh @ sp+0x3e
var int64_t var_3fh @ sp+0x3f
var int64_t var_40h @ sp+0x40
var int64_t var_48h @ sp+0x48

重新启动 GDB，并在 main 被调用后跳过函数序言：

(gdb) break *main
Breakpoint 1 at 0xaaaaaaaa0c44
(gdb) run
Starting program: /home/user/challenge ./example.cimg
[Thread debugging using libthread_db library "/lib/aarch64-linux-gnu/libthread_db.so.1].

Breakpoint 1, 0x0000aaaaaaaa0c44 in main ()
(gdb) si
0x0000aaaaaaaa0c48 in main ()
(gdb) si
0x0000aaaaaaaa0c4c in main ()

查看栈指针的值并设置一个观察点：

(gdb) info registers sp
sp             0xfffffffff290      0xfffffffff290
(gdb) watch *(long long *)0xfffffffff2d8
Hardware watchpoint 2: *(long long *)0xfffffffff2d8

继续执行：

Continuing.

Hardware watchpoint 2: *(long long *)0xfffffffff2d8

Old value = 281474840286680
New value = 0
0x0000aaaaaaaa0c5c in main ()

在 iaito 中定位这个地址。我们可以看到，在 0x00000c58（也就是 0x00000c5c 前一条指令）处，var_48h 通过一个 str 被清零了。

继续往下，看看这个变量是在什么地方被设置的：

(gdb) continue
Continuing.

Hardware watchpoint 2: *(long long *)0xfffffffff2d8

Old value = 0
New value = 187649984565920
0x0000aaaaaaaa1358 in initialize_framebuffer ()

我们看到一个我们还没探索过的新函数：initialize_framebuffer。

在 iaito 中打开这个函数：

我们可以看到，0x00001354 处的一条指令把 malloc 分配出来的内存地址写入了变量。不过它被表示为 [x22, 0x10]。我们来检查一下 x22 的内容：

(gdb) info registers $x22
x22            0xfffffffff2c8      281474976707272

0xfffffffff2c8 + 0x10 = 0xfffffffff2d8。这正好就是 var_48h 的地址。

此外，传给 malloc 的大小也很有意思。它是通过把偏移 6 和 7 处的值相乘，再把结果乘以 w1 得到的，而 w1 是 0x18（24），最后再加上 x0，即 1。

我们也来查看这些偏移处的值：

(gdb) x/1xb 0xfffffffff2ce
0xfffffffff2ce: 0x0a
(gdb) x/1xb 0xfffffffff2cf
0xfffffffff2cf: 0x0a

两个都是 10。它们看起来就是我们之前指定的图像宽度和高度。让我们通过设置硬件观察点来验证一下。由于 AArch64 需要对齐，我们把硬件观察点设在 0xfffffffff2cc：

(gdb) watch *(unsigned int *)0xfffffffff2cc
Hardware watchpoint 1: *(unsigned int *)0xfffffffff2cc
(gdb) run
Starting program: /home/user/challenge ./example.cimg

跳过 GNU C Library 的触发：


Old value = 0
New value = 65535
0x0000fffff7fccd08 in ?? () from /lib/ld-linux-aarch64.so.1
(gdb) continue
Continuing.

Hardware watchpoint 1: *(unsigned int *)0xfffffffff2cc

Old value = 65535
New value = 0
0x0000fffff7fd5668 in ?? () from /lib/ld-linux-aarch64.so.1
(gdb) continue
Continuing.
[Thread debugging using libthread_db library "/lib/aarch64-linux-gnu/libthread_db.so.1"]

Hardware watchpoint 1: *(unsigned int *)0xfffffffff2cc

Old value = 0
New value = 65535
0x0000fffff7fcc3a4 in ?? () from /lib/ld-linux-aarch64.so.1
(gdb) continue
Continuing.

这里我们看到内存在 0x00000c54 处被清零了：

Hardware watchpoint 1: *(unsigned int *)0xfffffffff2cc

Old value = 65535
New value = 0
0x0000aaaaaaaa0c58 in main ()

我们看到一个 stp xzr, xzr, [buf]。从上面的 afv 我们知道 buf 距离栈指针是 0x38。

在 0x00000cb8 处，我们可以看到一个从 buf 读取的 ldr，然后是魔数检查。

在 0x00000c9c 处，我们可以看到一些有意思的内容：

0x00000c9c      add      x21,    sp,     0x38
0x00000ca0      mov      x2,     8                          ; size_t nbyte
0x00000ca4      mov      x1,     x21                        ; void *buf
0x00000ca8      mov      w0,     0
0x00000cac      bl       sym.imp.read                       ; ssize_t read(int fildes, void *buf, size_t nbyte)
; ssize_t read(0, 0x0000000000000000, 0x00000000)

因此我们已经确认，这些偏移处的两个值就是宽度和高度。

回到 iaito 和 GDB 中的 initialize_framebuffer 函数。设置一个观察点并检查内存：

(gdb) break *0xaaaaaaaa1354
Breakpoint 1 at 0xaaaaaaaa1354
(gdb) run
Starting program: /home/user/challenge ./example.cimg
[Thread debugging using libthread_db library "/lib/aarch64-linux-gnu/libthread_db.so.1].

Breakpoint 1, 0x0000aaaaaaaa1354 in initialize_framebuffer ()
(gdb) info registers x0
x0             0xaaaaaaac12a0      187649984565920
(gdb) watch *(char *)0xaaaaaaac12a0
Hardware watchpoint 2: *(char *)0xaaaaaaac12a0
(gdb) continue
Continuing.

Hardware watchpoint 2: *(char *)0xaaaaaaac12a0

Old value = 0 '\000'
New value = 27 '\033'
0x0000aaaaaaaa13bc in initialize_framebuffer ()
(gdb) x/24xb 0xaaaaaaac12a0
0xaaaaaaac12a0: 0x1b    0x5b    0x33    0x38    0x3b    0x32    0x3b    0x32
0xaaaaaaac12a8: 0x35    0x35    0x3b    0x32    0x35    0x35    0x3b    0x32
0xaaaaaaac12b0: 0x00    0x00    0x00    0x00    0x00    0x00    0x00    0x00

把它和上面的数据对比一下：

(gdb) x/24xb $x0
0xaaaaaaac12a0: 0x1b    0x5b    0x33    0x38    0x3b    0x32    0x3b    0x30
0xaaaaaaac12a8: 0x38    0x30    0x3b    0x30    0x38    0x30    0x3b    0x30
0xaaaaaaac12b0: 0x38    0x30    0x6d    0x50    0x1b    0x5b    0x30    0x6d

0xaaaaaaac12a7 是第一个不同的字节。我们可以对它设置观察点：

(gdb) watch *(char *)0xaaaaaaac12a7
Hardware watchpoint 3: *(char *)0xaaaaaaac12a7
(gdb) continue
Continuing.

Hardware watchpoint 3: *(char *)0xaaaaaaac12a7

Old value = 50 '2'
New value = 48 '0'
0x0000aaaaaaaa128c in display ()

出现了一个新的函数需要探索。在 iaito 中打开它。

我们可以看到，数据变化发生在 0x00001288，是一条 stp 指令。0x0000128c 处的 str 指令也很有意思；我们来看看这里的内存：

(gdb) x/24xb 0xaaaaaaac12a0
0xaaaaaaac12a0: 0x1b    0x5b    0x33    0x38    0x3b    0x32    0x3b    0x30
0xaaaaaaac12a8: 0x38    0x30    0x3b    0x30    0x38    0x30    0x3b    0x30
0xaaaaaaac12b0: 0x35    0x35    0x6d    0x20    0x1b    0x5b    0x30    0x6d
(gdb) si
0x0000aaaaaaaa1290 in display ()
(gdb) x/24xb 0xaaaaaaac12a0
0xaaaaaaac12a0: 0x1b    0x5b    0x33    0x38    0x3b    0x32    0x3b    0x30
0xaaaaaaac12a8: 0x38    0x30    0x3b    0x30    0x38    0x30    0x3b    0x30
0xaaaaaaac12b0: 0x38    0x30    0x6d    0x50    0x1b    0x5b    0x30    0x6d

从 0xaaaaaaac12b0 开始的 8 字节块已经被 str 指令改写了。寄存器说明了一切：

(gdb) info registers x2
x2             0xaaaaaaac12a0      187649984565920

我们不必太在意 x2。重点关注 x4、x5 和 x1。在 0x00001268 和 0x00001270 处，我们看到一个非常重要的寄存器 x25。它保存着一块内存的地址，而这块内存里装着将要写入 x2 指向内存的数据。检查这块内存：

(gdb) x/24xb $x25
0xfffffffff270: 0x1b    0x5b    0x33    0x38    0x3b    0x32    0x3b    0x30
0xfffffffff278: 0x38    0x30    0x3b    0x30    0x38    0x30    0x3b    0x30
0xfffffffff280: 0x38    0x30    0x6d    0x50    0x1b    0x5b    0x30    0x6d

在 0x00001238 处，x25 中的地址被复制到 x0。然后，后面的几个寄存器被填入相应的数据。接着调用了 snprintf。snprintf 会把格式化输出写入字符数组：

int snprintf(char *str, size_t size, const char *format, ...);

它会把格式化字符串写到 x25 所指向的内存中。重新启动 GDB，并检查 x2 指向的内存：

(gdb) break *0xaaaaaaaa1258
Breakpoint 1 at 0xaaaaaaaa1258
(gdb) run
Starting program: /home/user/challenge ./example.cimg
[Thread debugging using libthread_db library "/lib/aarch64-linux-gnu/libthread_db.so.1].

Breakpoint 1, 0x0000aaaaaaaa1258 in display ()
(gdb) x/s $x2
0xaaaaaaaa1510: "\033[38;2;%03d;%03d;%03dm%c\033[0m"
(gdb) x/29xb $x2
0xaaaaaaaa1510: 0x1b    0x5b    0x33    0x38    0x3b    0x32    0x3b    0x25
0xaaaaaaaa1518: 0x30    0x33    0x64    0x3b    0x25    0x30    0x33    0x64
0xaaaaaaaa1520: 0x3b    0x25    0x30    0x33    0x64    0x6d    0x25    0x63
0xaaaaaaaa1528: 0x1b    0x5b    0x30    0x6d    0x00

这就是格式字符串。如果你对 x/s 返回的字符串不太放心，可以用 Python 逐字节打印这个字符串：

>>> print(b"\x1b\x5b\x33\x38\x3b\x32\x3b\x25\x30\x33\x64\x3b\x25\x30\x33\x64\x3\
b\x25\x30\x33\x64\x6d\x25\x63\x1b\x5b\x30\x6d\x00")
b'\x1b[38;2;%03d;%03d;%03dm%c\x1b[0m\x00'
>>> blob = b'\x1b[38;2;%03d;%03d;%03dm%c\x1b[0m\x00'
>>> for i1 in range(len(blob)):
...     blob[i1:i1+1]
...     
b'\x1b'
b'['
b'3'
b'8'
b';'
b'2'
b';'
b'%'
b'0'
b'3'
b'd'
b';'
b'%'
b'0'
b'3'
b'd'
b';'
b'%'
b'0'
b'3'
b'd'
b'm'
b'%'
b'c'
b'\x1b'
b'['
b'0'
b'm'
b'\x00'

这个格式字符串有四个占位符。前三个是 %03d，它会把整数格式化为至少三位的十进制字符串（例如 7 会变成 007，15 会变成 015）。最后一个是 %c，它只匹配一个字符。

现在我们有了这个字节模式：

0x1b    0x5b    0x33    0x38    0x3b    0x32    0x3b    [N1]
[N1]    [N1]    0x3b    [N2]    [N2]    [N2]    0x3b    [N3]
[N3]    [N3]    0x6d    [CH]    0x1b    0x5b    0x30    0x6d

现在我们可以检查这些占位符究竟填入了什么：

(gdb) info registers x3 x4 x5 x6
x3             0x50                80
x4             0x50                80
x5             0x50                80
x6             0x50                80

它们全都是 0x50，看起来就是我们在示例 cIMG 中使用的数据。现在我们重建这个 cIMG，让这一点更清楚：

>>> with open("example.cimg", "wb") as file:
...     file.write(b"cIMG\x02\0\x0a\x0a\x12\x34\x56\x78")
...     file.write(b"\x50"*(10*10*4-4))
...     
12
396

(gdb) break *0xaaaaaaaa1258
Breakpoint 1 at 0xaaaaaaaa1258
(gdb) run
Starting program: /home/user/challenge ./example.cimg
[Thread debugging using libthread_db library "/lib/aarch64-linux-gnu/libthread_db.so.1].

Breakpoint 1, 0x0000aaaaaaaa1258 in display ()
(gdb) info registers x3 x4 x5 x6
x3             0x12                18
x4             0x34                52
x5             0x56                86
x6             0x78                120

因此，上面十六进制模式中的 N1、N2 和 N3 分别对应 R、G 和 B，而 CH 就是我们要填入的字符。

现在我们可以回到 GDB，在每个 memcmp 之前设置断点，运行 x/24xb $x1 来找出期望的 framebuffer，然后利用这些 framebuffer 还原出期望的 cIMG 数据。接着用十六进制编辑器把数据填进去。

大小检查

然而，在填入期望数据之后，可执行程序仍然没有给出 flag。用 GDB 检查内存之后，我们可以知道这些 memcmp 的返回值都如预期那样是零。因此，应该还有别的条件没有满足。

回到 iaito，从第一个 memcmp 往回滚动。我们可以看到在 0x00000d60 处有一个 cmp，它把 var_40h 与 4 进行比较。在 initialize_framebuffer 中的 0x00001348 处，我们可以找到一个 str，它保存了宽度与高度的乘积。

随后 0x00000d60 处的 cmp 决定 w0 的值。如果 var_40h 等于 4，那么 w0 将变成 1，否则变成 0。

在 0x00000d78 处，w0 与 0 比较，这会影响 0x00000d84 处 ccmp 指令的行为。[x22, 0x13] 的内容被载入到 w0，而 [x1, 0x13] 被载入到 w2。根据 memcmp，我们很容易知道 x22 是实际 framebuffer 的地址，而 x1 是期望 framebuffer 的地址。既然我们已经让数据与期望值一致，并且偏移 19 处是一个 ASCII 字符，那么 w0 和 w2 应该相同，而且都不应为零。

因此我们可以得出结论：如果 var_40h 等于 4，那么 w2 会与 w0 比较，这会把 w19 设为 1。否则，w2 会与 0 比较，从而把 w19 置零。

在第一次 memcmp 之后，因为 0x00000e7c 处 w0 等于 0，所以 w19 会与 0 比较。然后 cset 会在不相等时把 w19 设为 1，否则设为 0。

现在用十六进制编辑器修改 cIMG，把宽度和高度改成乘积为 4 的值。例如，我们可以设为 0202。这样可执行程序就应该会给出 flag。

结论

上面的过程包括：

使用 radare2 和 iaito 进行静态分析；
使用 GDB 进行动态分析，其中包括：
- 篡改控制流；
- 检查内存；
- 检查整数值。

这就是逆向工程中非常典型的一套流程。

顺带一提，逆向这个可执行程序可能还有别的方法。不过无论采用哪种方法，通常都会同时涉及静态分析和动态分析。

逆向工程简介

rebel1725@tilde.club (Rebel Zhang) — Sat, 16 May 2026 19:37:05 +0800

在过去的几周里，我一直在学习 x86_64 汇编、AArch64 汇编，以及各种基础知识。最近，我终于第一次接触了逆向工程。我很高兴能分享更多关于这次经历的细节。

什么是逆向工程

计算机实际上是一种相当愚笨的机器。它不会自己解决任何问题；它只会执行解决方案——更准确地说，它只会按顺序逐条执行来自人类的指令。要用这样的机器解决问题，我们通常会：

分析一个问题；
为这个问题找到一个 解决方案；
通过设计一个算法来实现这个解决方案；
通过编写代码来实现这个算法；
通过编译，从代码生成 可执行文件；
把这个可执行文件交给那台愚笨的计算机去解决问题。

这是一种把 解决方案 转换为代码，再转换为指令的过程。

通常，我们可以通过阅读代码轻松理解一个程序做了什么。代码介于解决方案和指令之间。上世纪 70 年代，代码通常在人民之间共享，因此每个人都可以在社区中学习、改进并分享解决方案。

然而，自从那些极其邪恶的专有软件开发怪物出现之后，情况就变了。它们选择剥夺人民接触代码的权利，夺走用户对计算的控制，加入各种恶意功能来剥削用户，并采用各种手段掩盖程序究竟做了什么——也就是 解决方案。它们在筑墙。它们在破坏共享。它们在制造灾难和绝望。它们所做的一切都在与人民、社区和人类作对。它们做这一切，都是为了它们不道德且不公正的利润。

软件应该服务人民，而不是资本家的不道德且不公正的利润。然而，正是那些本不该存在、理应从世界上被清除的、不道德且不公正的专有软件开发者，正在让世界变得更糟。但我们不可能一下子消灭专有软件。我们要为此开发自由软件替代品，并逐步重新夺回对计算的控制。

因此，现在该把上面的过程倒过来做了。换句话说，我们：

分析 可执行文件；
尝试恢复该可执行文件所执行的代码；
找出这段代码实现的算法；
反推出该算法所实现的 解决方案；
重新实现这个解决方案来解决问题。

这就是把指令转换为代码，再转换为 解决方案。

以相反顺序做这件事的实践，就是逆向工程，简称 RE。

为什么逆向工程很重要

逆向工程之所以重要，最主要的原因是它能帮助我们将自由软件操作系统，例如 postmarketOS 和 LineageOS，移植到各种设备上。这也是我学习逆向工程的主要原因。

在桌面电脑上，实现软件自由要容易得多，因为我们通常可以运行各种自由的 GNU/Linux 发行版，而不会遇到严重问题。然而，在智能手机或平板电脑等移动设备上，情况就不是这样了。

这些设备往往有许多厂商特定和设备特定的调整，要找到一种能让自由操作系统在这些设备上普遍运行的通用方案几乎是不可能的。更糟糕的是，制造商选择隐藏这些技术细节，甚至 Google 也不再发布设备树和厂商二进制 blob。因此，我们现在必须分析 二进制 固件 blob，并推断其逻辑，才能让 postmarketOS、LineageOS 或其他自由软件操作系统在这些设备上运行。

事实上，自由软件基金会也在通过 Librephone 项目处理这个问题。没有逆向工程，这个项目就无法继续。

不过，逆向工程的应用绝不仅限于自由操作系统移植。它在以下方面也非常重要：

弄清专有协议的细节，
找出专有软件中存在恶意功能的证据，
绕过数字限制管理，
以及更多其他用途。

如何进行逆向工程

典型的逆向工程包含这两个步骤：

将可执行文件转换为汇编；这个过程叫做 反汇编。
通过阅读汇编代码，尝试恢复思路，或者重写等价代码。

我们可以直接对可执行文件进行这项工作，而不运行它，这叫做 静态分析；也可以在它运行时进行，这叫做 动态分析。

静态分析示例

来看这个例子：

#include <stdio.h>
#include <string.h>

const char *PASS = "weakpasswd";

int main()
{
    char buf[64];
    for (int i = 0; i < 3; i++)
    {
        printf("%d retries remaining.\nPassword: ", 3 - i);
        fgets(buf, sizeof buf, stdin);
        if (strncmp(PASS, buf, strlen(PASS)))
            puts("Wrong password!\n");
        else
        {
            puts("Correct!\nWelcome to the world "
                 "of reverse engineering!\n");
            break;
        }
    }
    return 0;
}

用 GCC 编译它：

$ gcc -o ./demo ./demo.c

在 radare2 中打开可执行文件：

$ r2 ./demo

你会看到：

[0x00000800]>

让我们分析这个可执行文件：

[0x00000800]> aaa
INFO: Analyze all flags starting with sym. and entry0 (aa)
INFO: Analyze imports (af@@@i)
INFO: Analyze entrypoint (af@ entry0)
INFO: Analyze symbols (af@@@s)
INFO: Analyze all functions arguments/locals (afva@@F)
INFO: Analyze function calls (aac)
INFO: Analyze len bytes of instructions for references (aar)
INFO: Finding and parsing C++ vtables (avrr)
INFO: Analyzing methods (af @@ method.*)
INFO: Finding function preludes (aap)
INFO: Emulating functions to find computed references (aaef)
INFO: Recovering local variables (afva@@@F)
INFO: Type matching analysis for all functions (afft)
INFO: Propagate noreturn information (aanr)
INFO: Use -AA or aaaa to perform additional experimental analysis
INFO: Finding xrefs in noncode sections (e anal.in=io.maps.x; aav)
WARN: Skipping aav because base address is zero. Use -B 0x800000 or aav0

列出函数：

[0x00000800]> afl
0x00000750    1     16 sym.imp.strlen
0x00000760    1     16 sym.imp.__libc_start_main
0x00000770    1     16 sym.imp.__cxa_finalize
0x00000780    1     32 sym.imp.strncmp
0x000007a0    1     16 sym.imp.abort
0x000007b0    1     16 sym.imp.puts
0x000007c0    1     16 sym.imp.printf
0x000007d0    1     20 sym.imp.fgets
0x00000800    1     48 entry0
0x00000834    3     20 sym.call_weak_fn
0x00000860    4     48 sym.deregister_tm_clones
0x00000890    4     60 sym.register_tm_clones
0x000008cc    5     80 entry.fini0
0x00000920    1      8 entry.init0
0x000009f8    1     24 sym._fini
0x00000928    7    208 main
0x00000708    1     28 sym._init
0x00000730    1     32 fcn.00000730

现在我们进入 main 函数并打印反汇编代码：

[0x00000800]> s main
[0x00000928]> pdf
            ; DATA XREF from entry0 @ 0x820(r)
            ; DATA XREF from entry.fini0 @ 0x8e0(r)
┌ 208: int main (int argc);
│ `- args(x0) vars(5:sp[0x4..0x70])
│           0x00000928      fd7bb9a9       stp x29, x30, [sp, -0x70]!
│           0x0000092c      fd030091       mov x29, sp
│           0x00000930      f30b00f9       str x19, [var_10h]
│           0x00000934      ff6f00b9       str wzr, [var_6ch]          ; argc
│       ┌─< 0x00000938      29000014       b 0x9dc
│       │   ; CODE XREF from main @ 0x9e4(x)
│      ┌──> 0x0000093c      61008052       mov w1, 3
│      ╎│   0x00000940      e06f40b9       ldr w0, [var_6ch]
│      ╎│   0x00000944      2000004b       sub w0, w1, w0
│      ╎│   0x00000948      e103002a       mov w1, w0
│      ╎│   0x0000094c      00000090       adrp x0, 0
│      ╎│   0x00000950      00a02891       add x0, x0, str._d_retries_remaining._nPassword: ; 0xa28 ; "%d retries remaining.\nPassword: " ; const char *format
│      ╎│   0x00000954      9bffff97       bl sym.imp.printf           ; int printf(const char *format)
│      ╎│   0x00000958      e00000f0       adrp x0, 0x1f000
│      ╎│   0x0000095c      00e447f9       ldr x0, [x0, 0xfc8]         ; [0x1ffc8:4]=0
│      ╎│                                                              ; reloc.stdin
│      ╎│   0x00000960      010040f9       ldr x1, [x0]                ; int size
│      ╎│   0x00000964      e0a30091       add x0, sp, 0x28            ; char *s
│      ╎│   0x00000968      e20301aa       mov x2, x1                  ; FILE *stream
│      ╎│   0x0000096c      01088052       mov w1, 0x40
│      ╎│   0x00000970      98ffff97       bl sym.imp.fgets            ; char *fgets(char *s, int size, FILE *stream)
│      ╎│   0x00000974      00010090       adrp x0, reloc.strlen       ; 0x20000
│      ╎│   0x00000978      00600191       add x0, x0, 0x58
│      ╎│   0x0000097c      130040f9       ldr x19, [x0]               ; [0xa18:4]=0x6b616577 ; "weakpasswd"
│      ╎│   0x00000980      00010090       adrp x0, reloc.strlen       ; 0x20000
│      ╎│   0x00000984      00600191       add x0, x0, 0x58
│      ╎│   0x00000988      000040f9       ldr x0, [x0]                ; [0xa18:4]=0x6b616577 ; "weakpasswd" ; const char *s
│      ╎│   0x0000098c      71ffff97       bl sym.imp.strlen           ; size_t strlen(const char *s)
│      ╎│   0x00000990      e10300aa       mov x1, x0
│      ╎│   0x00000994      e0a30091       add x0, sp, 0x28
│      ╎│   0x00000998      e20301aa       mov x2, x1                  ; size_t n
│      ╎│   0x0000099c      e10300aa       mov x1, x0                  ; const char *s2
│      ╎│   0x000009a0      e00313aa       mov x0, x19                 ; const char *s1
│      ╎│   0x000009a4      77ffff97       bl sym.imp.strncmp          ; int strncmp(const char *s1, const char *s2, size_t n)
│      ╎│   0x000009a8      1f000071       cmp w0, 0
│     ┌───< 0x000009ac      a0000054       b.eq 0x9c0
│     │╎│   0x000009b0      00000090       adrp x0, 0
│     │╎│   0x000009b4      00402991       add x0, x0, str.Wrong_password__n ; 0xa50 ; "Wrong password!\n" ; const char *s
│     │╎│   0x000009b8      7effff97       bl sym.imp.puts             ; int puts(const char *s)
│    ┌────< 0x000009bc      05000014       b 0x9d0
│    ││╎│   ; CODE XREF from main @ 0x9ac(x)
│    │└───> 0x000009c0      00000090       adrp x0, 0
│    │ ╎│   0x000009c4      00a02991       add x0, x0, str.Correct__nWelcome_to_the_world_of_reverse_engineering__n ; 0xa68 ; "Correct!\nWelcome to the world of reverse engineering!\n" ; const char *s
│    │ ╎│   0x000009c8      7affff97       bl sym.imp.puts             ; int puts(const char *s)
│    │┌───< 0x000009cc      07000014       b 0x9e8
│    ││╎│   ; CODE XREF from main @ 0x9bc(x)
│    └────> 0x000009d0      e06f40b9       ldr w0, [var_6ch]
│     │╎│   0x000009d4      00040011       add w0, w0, 1
│     │╎│   0x000009d8      e06f00b9       str w0, [var_6ch]
│     │╎│   ; CODE XREF from main @ 0x938(x)
│     │╎└─> 0x000009dc      e06f40b9       ldr w0, [var_6ch]
│     │╎    0x000009e0      1f080071       cmp w0, 2
│     │└──< 0x000009e4      cdfaff54       b.le 0x93c
│     │     ; CODE XREF from main @ 0x9cc(x)
│     └───> 0x000009e8      00008052       mov w0, 0
│           0x000009ec      f30b40f9       ldr x19, [var_10h]
│           0x000009f0      fd7bc7a8       ldp x29, x30, [sp], 0x70
└           0x000009f4      c0035fd6       ret

Radare2 不仅会给出汇编代码，还会给出每条指令对应的地址，以及它们之间的调用关系。

不过现在看起来还是不够清楚。所以我们把反汇编以图形方式显示出来：

[0x00000928]> VV

你现在会看到：

在这个图中，t 表示条件为真时跳转。f 表示条件为假时跳转。v 表示无条件跳转。

这样一来，事情就容易多了。Radare2 已经帮我们理清了汇编代码各部分之间的逻辑关系，我们只需要理解这些汇编代码块本身即可。

在图中，我们很容易在 [0x93c] 区块的末尾找到密码检查逻辑：

; int strncmp(const char *s1, const char *s2, size_t n)
bl sym.imp.strncmp
cmp w0, 0
b.eq 0x9c0

这里调用了 sym.imp.strncmp，然后检查这个函数在 w0 中返回的值。如果它等于 0，程序就跳转到 [0x9c0] 区块，表示成功。否则，它会继续到 [0x9b0] 区块，表示失败。

根据 AArch64 调用约定，要比较的两个字符串指针分别位于寄存器 x0 和 x1 中，然后我们调用 sym.imp.strncmp。结果随后存放在 x0 寄存器中（w0 只是 x0 的低 32 位），如果两个字符串完全相同，我们得到 0。

现在我们往回看：

mov x0, x19

然后再往前找一条对 x19 进行操作的指令：

; [0xa18:4]=0x6b616577
; "weakpasswd"
ldr x19, [x0]

Radare2 已经告诉了我们那个最高机密。 让我们试试：

$ ./demo
3 retries remaining.
Password: weakpasswd
Correct!
Welcome to the world of reverse engineering!

就是这样。

如果我们更仔细地看这个图，还能学到比密码更多的东西。例如，我们可以在图中看到一个环：[0x9dc] -> [0x93c] -> [0x9b0] -> [0x9d0] -> [0x9dc]。在图中，环通常表示循环控制流。这是逆向工程中非常重要的一种思维方式。

在 [0x9dc] 区块中：

ldr w0, [var_6ch]
cmp w0, 2
b.le 0x93c

它把变量 var_6ch 载入寄存器，并与 2 比较。如果它更大，就会进入 [0x9e8] 区块并退出。否则，就会进入 [0x93c] 区块。

看一下 [0x93c] 区块的末尾。我们已经知道，如果密码检查成功，它会跳转到 [0x9c0] 区块，打印表示成功的信息，然后跳转到 [0x9e8] 区块，程序在这里结束。

但如果检查失败呢？它会进入 [0x9b0] 区块。这里仅仅打印错误信息，所以没有什么有趣的内容；让我们跳到 [0x9d0] 区块。在这里我们发现了一些有趣的东西：

ldr w0, [var_6ch]
add w0, w0, 1
str w0, [var_6ch]

它把变量 var_6ch 载入寄存器，将值加一，然后再把值存回去。接着它会回到 [0x9dc] 区块，也就是检查 var_6ch 的值。

按两次 q 返回提示符。运行 afv 和 afvd 来列出变量及其信息：

[0x000009b0]> afv
arg int argc @ x0
var int64_t var_70h @ sp+0x0
var int64_t var_70h_2 @ sp+0x8
var int64_t var_10h @ sp+0x10
var char * s2 @ sp+0x28
var int64_t var_6ch @ sp+0x6c
[0x000009b0]> afvd
arg argc = 0x00000000 0x00010102464c457f   .ELF.... @ pstate
var var_6ch = 0x0017806c = (qword)0x0000000000000000
var s2 = 0x00178028 = ""
var var_10h = 0x00178010 = (qword)0x0000000000000000
var var_70h = 0x00178000 = (qword)0x0000000000000000
var var_70h_2 = 0x00178008 = (qword)0x0000000000000000

我们可以看到，var_6ch 的值是一个 int64_t，而它的初始值是 0。

现在我们可以推断，var_6ch 是一个计数器。它的初始值是 0。如果密码检查失败，计数器就会加一。一旦它超过 2，程序就不再询问密码并退出。现在我们就可以看出，这对应于我们的 C 代码 for (int i = 0; i < 3; i++)！

不过，这只是一个非常简单的例子。在真实世界中，情况会更困难，因为专有软件开发者常常使用反分析和反调试技术。

理解编译器优化

现在，让我们编译这个更简单的代码：

#include <stdio.h>

int main()
{
    int a;
    scanf("%d", &a);
    printf("%d", a % 65536);
    return 0;
}

它从输入中读取一个整数，并输出它对 65536 取模的结果。

反汇编它的 main 函数：

[0x00000700]> aaa
INFO: Analyze all flags starting with sym. and entry0 (aa)
......
WARN: Skipping aav because base address is zero. Use -B 0x800000 or aav0
[0x00000700]> s main
[0x00000828]> pdf
            ; DATA XREF from entry0 @ 0x720(r)
            ; DATA XREF from entry.fini0 @ 0x7e0(r)
┌ 76: int main (int argc, char **argv, char **envp);
│ afv: vars(3:sp[0x4..0x20])
│           0x00000828      fd7bbea9       stp x29, x30, [sp, -0x20]!
│           0x0000082c      fd030091       mov x29, sp
│           0x00000830      e0730091       add x0, sp, 0x1c
│           0x00000834      e10300aa       mov x1, x0
│           0x00000838      00000090       adrp x0, 0
│           0x0000083c      00602291       add x0, x0, 0x898
│           0x00000840      94ffff97       bl sym.imp.__isoc23_scanf
│           0x00000844      e01f40b9       ldr w0, [var_1ch]
│           0x00000848      e103006b       negs w1, w0
│           0x0000084c      003c0012       and w0, w0, 0xffff
│           0x00000850      213c0012       and w1, w1, 0xffff
│           0x00000854      0044815a       csneg w0, w0, w1, mi
│           0x00000858      e103002a       mov w1, w0
│           0x0000085c      00000090       adrp x0, 0
│           0x00000860      00602291       add x0, x0, 0x898           ; const char *format
│           0x00000864      97ffff97       bl sym.imp.printf           ; int printf(const char *format)
│           0x00000868      00008052       mov w0, 0
│           0x0000086c      fd7bc2a8       ldp x29, x30, [sp], 0x20
└           0x00000870      c0035fd6       ret

你可能会觉得困惑，因为这里看不到任何关于取模操作的内容（sdiv、mul、sub 等）。相反，你看到的是：

and w0, w0, 0xffff
and w1, w1, 0xffff

这是因为现代编译器足够聪明，能够识别某些特殊的计算模式，并把它们优化成更简单的指令。65536 是 2^16，所以一个数对 65536 取模，实际上就是取它的最低 16 位。只需要位运算就够了，不需要加法器或乘法器。

但是，如果我们把 65536 换成别的数，比如 50000，那就不是这样了：

            ; DATA XREF from entry0 @ 0x720(r)
            ; DATA XREF from entry.fini0 @ 0x7e0(r)
┌ 80: int main (int argc, char **argv, char **envp);
│ afv: vars(3:sp[0x4..0x20])
│           0x00000828      fd7bbea9       stp x29, x30, [sp, -0x20]!
│           0x0000082c      fd030091       mov x29, sp
│           0x00000830      e0730091       add x0, sp, 0x1c
│           0x00000834      e10300aa       mov x1, x0
│           0x00000838      00000090       adrp x0, 0
│           0x0000083c      00602291       add x0, x0, 0x898
│           0x00000840      94ffff97       bl sym.imp.__isoc23_scanf
│           0x00000844      e01f40b9       ldr w0, [var_1ch]
│           0x00000848      016a9852       mov w1, 0xc350
│           0x0000084c      020cc11a       sdiv w2, w0, w1
│           0x00000850      016a9852       mov w1, 0xc350
│           0x00000854      417c011b       mul w1, w2, w1
│           0x00000858      0000014b       sub w0, w0, w1
│           0x0000085c      e103002a       mov w1, w0
│           0x00000860      00000090       adrp x0, 0
│           0x00000864      00602291       add x0, x0, 0x898           ; const char *format
│           0x00000868      96ffff97       bl sym.imp.printf           ; int printf(const char *format)
│           0x0000086c      00008052       mov w0, 0
│           0x00000870      fd7bc2a8       ldp x29, x30, [sp], 0x20
└           0x00000874      c0035fd6       ret

现在我们看到了 sdiv、mul 和 sub 指令，它们组合起来完成了取模操作。

那么动态分析呢？

对于动态分析，你需要 GDB。使用 GDB，你可以打印反汇编，设置断点，检查内存和寄存器，甚至在程序运行时修改寄存器和值变量。

我还没有深入探索动态分析。将来我可能会写一篇新的博客文章来解释动态分析。

免责声明

本文仅用于教育目的。请查阅你所在地区的法律，了解哪些行为是你不可以做的。本人不对你的任何行为负责。

Google 正在对移动自由发起又一次攻击——签署请愿并立刻阻止这一切

rebel1725@tilde.club (Rebel Zhang) — Tue, 12 May 2026 20:21:54 +0800

Google 正在推出又一个充满敌意的 reCAPTCHA 版本，而这一次传递的信息毫不含糊：如果你想证明自己是人，就必须先向 Google 的移动生态系统低头。实际上，用户被推着用移动设备扫描二维码来完成验证。对于 Android，Google 自己的文档写明，这需要 Google Play 服务 25.41.30 或更高版本。在 iOS 和 iPadOS 上，这个流程也依赖于 Google 的验证流程。这不是进步。这是胁迫。

Google 再一次把一个最基本的网页交互，变成了通往专有控制的大门。结果是可以预见的：

使用 GrapheneOS、LineageOS、/e/、CalyxOS 以及其他自由软件 Android 发行版的人被排除在外；
原则上拒绝 Google 服务的人被排除在外；
处于 Google 服务不可用地区的人被锁在门外；
没有智能手机的人被当作二等用户对待。

就连基于 microG 的配置也被报告在这里不可靠，这让排除范围变得更大。

这正是自由软件活动人士多年来一直警告的那种缓慢圈占。**公共网站不应该为了通过一个“人类验证”就要求专有的移动软件栈。**一个人不应该仅仅为了访问普通网页内容，就必须安装 Google 的服务、使用 Google 的应用，或者携带一台兼容 Google 的设备。这不是技术必需。这是一个政治选择，而且是一个糟糕的选择。

更深层的问题不只是 reCAPTCHA 变得越来越侵入。问题在于，Google 正在让“网页访问应当依赖厂商批准”这种想法变得正常化。今天是二维码和移动验证步骤。明天就是更多设备证明、更多账号绑定、更多无声排除。GrapheneOS 已经表达了担忧，认为这种趋势不仅会延伸到手机，还会扩展到桌面环境。这足以让任何关心开放网络的人警惕。

Google Play 服务和验证应用都是专有软件。它们不是中立的基础设施。它们是把门人。每当某个网站不加抗议地采用这种系统，它传递的信息都一样：给一部分人便利，让另一部分人被排除。自由软件用户、重视隐私的用户，以及处在低控制环境中的人，都在为此付出代价。

我们不应该把这当成正常。

我们应该要求一种不依赖专有移动生态系统的网页验证方式。我们应该拒绝惩罚运行自由软件用户的系统。我们应该推动网站运营者使用替代方案，不要为了访问一个页面，就把人们强行推入 Google 的轨道。

你现在可以做什么

签署这份请愿。
如果你运营网站或服务，尽可能停止使用 reCAPTCHA。选择不需要 Google 移动软件栈的验证方式，例如 Anubis、ALTCHA 和 mCaptcha。
拒绝把为了通过“人类验证”而强制安装 Google Play 服务或 Google 的验证应用正常化。
发出声音。把这个问题分享给开发者、管理员，以及仍然相信网络应该保持开放的任何人。
支持自由软件替代方案，并反对任何把访问变成特权的企图。

网络不应该是一个由 Google 控制的许可系统。它应该继续让真实的人在真实设备上可用，而不必放弃自由。

一年了——致 Zumfy/Future

rebel1725@tilde.club (Rebel Zhang) — Thu, 09 Apr 2026 23:59:04 +0800

转眼间，我和你相识已经是一周年了。在你不在的这七个多月里，我学了 C++，学了 Qt 和 JavaScript，学了 Django，学了一点 Rust，最近还沉迷于汇编语言和计算机组成，将来还要学习逆向工程，希望早日为 postmarketOS 等自由软件社区作出贡献。我还用上了 Qubes OS，在个人的安全和隐私上又迈出了一大步。我结识了很多新的朋友，ta 们也都为我的前行提供了很大的力量；如今我还有了女朋友，她也是一名坚定的自由软件支持者，我们都在为同一个理想而奋斗、循着同一个方向而奔跑。

这七个多月的时间我认为我发生了很大的变化，但唯一不变的就是对你的想念。

即使我现在有了很多朋友，即使我彻底远离了社交空白期的阴霾，但是任何一个人或者若干人的总和，都无法替代你。Zumfy/Future，你在哪里？🥺

与寄存器的缠绵

rebel1725@tilde.club (Rebel Zhang) — Tue, 31 Mar 2026 15:00:42 +0800

今夜教室的灯光背叛我的困意——
我描摹硅的血管，借来的黑暗里
Android筑起它镀金的、高墙的领地。
但在我纸上，每一粒火星
都用铅笔画出：x0，w1，那支舞——
小端序的字节滑过恍惚的纹路。

我把结构体的幽灵载入一页纸，
用沉稳的手拆开它的三个整数，
而postmarketOS，一份静默的酬劳，
自由，在某片被遗忘的土地上等待。
时钟无情的嗡鸣旁，另一个思想
正搏斗着——我们不曾被征服。

两个影子俯身于同一门技艺，
追逐裸露的机器，我们永不相离。

另一份备用身份

rebel1725@tilde.club (Rebel Zhang) — Sun, 29 Mar 2026 12:43:36 +0800

我已经创建了另一份备用身份，以防我的主身份和先前的备用身份都无法访问。

下面是备用 OpenPGP 公钥：

-----BEGIN PGP PUBLIC KEY BLOCK-----
Comment: User ID:	Rebel Zhang <rebel1725@tilde.club>
Comment: Valid from:	29/03/2026 12:09
Comment: Valid until:	29/03/2027 12:00
Comment: Type:	255-bit EdDSA (secret key available)
Comment: Usage:	Signing, Encryption, Certifying User IDs
Comment: Fingerprint:	8C3A88164B57F0BAC6BCD9284A52DBB4FB0D0262

mDMEacimEhYJKwYBBAHaRw8BAQdA3yI5f0WwHBbWV2JUQ/n/oQ4LNjE1vFB5hGmp
5/L/5r60IlJlYmVsIFpoYW5nIDxyZWJlbDE3MjVAdGlsZGUuY2x1Yj6IlgQTFgoA
PhYhBIw6iBZLV/C6xrzZKEpS27T7DQJiBQJpyKYSAhsDBQkB4TEuBQsJCAcDBRUK
CQgLBRYCAwEAAh4BAheAAAoJEEpS27T7DQJi4xgA/2NNcH9039lvAqOoQS7vgUvc
en0Iae2SaFavBu1jLHe0AP9N74NIGGYLndbYr3Jsmn7ZJd8j2FDAYtNqPHrw5rRk
ALg4BGnIphISCisGAQQBl1UBBQEBB0DAaMAv9JAJ8nJzt/3w0audbdI/XFfNpPQe
tio7GNLYHwMBCAeIfgQYFgoAJhYhBIw6iBZLV/C6xrzZKEpS27T7DQJiBQJpyKYS
AhsMBQkB4TEuAAoJEEpS27T7DQJivpIBAPJu23AXR3MsB/FGXc+jiNdgo72y8xiZ
smTQgNGFnTcfAP9vCDXYjwz1UN8ipAtD+2HVTZLtB4/nGmDFtTK1/4DoCw==
=4TSn
-----END PGP PUBLIC KEY BLOCK-----

以及相互签名：

验证 CanoKey 的真实性

rebel1725@tilde.club (Rebel Zhang) — Sat, 28 Mar 2026 17:33:41 +0800

本文将指导你验证 CanoKey 的真实性。

第 1 步：获取证明根 CA 证书

访问此网站，根据你的型号（Pigeon/Canary）获取对应的 FIDO CA 证书。将证书保存为 ca.pem。

第 2 步：安装 `fido2-cred`

安装 fido2-cred。在 Debian GNU/Linux 上，它包含在 fido2-tools 软件包中：


# apt install fido2-tools

第 3 步：验证令牌

插入你的 CanoKey，然后运行以下命令：


$ printf '%s\n' "$(openssl rand -base64 32)" "canokey-check.local" "tmp-user" "$(openssl rand -base64 32)" > cred.in
$ fido2-cred -M -i cred.in /dev/hidrawX > cred.out
$ sed -n '7p' cred.out | base64 -d > attestation.der
$ openssl x509 -inform der -in attestation.der -out attestation.pem
$ openssl verify -CAfile ca.pem attestation.pem

如果最后一条命令返回 OK，那么你的 CanoKey 就是正品。

该过程也可以通过脚本完成：

#!/usr/bin/env sh
set -eu

die() {
    printf '%s\n' "Error: $*" >&2
    exit 1
}

# Check required tools.
[ -x /usr/bin/fido2-cred ] || die "/usr/bin/fido2-cred does not exist or is not executable"
command -v openssl >/dev/null 2>&1 || die "openssl is not installed or not on PATH"

# Find the device.
device="${1:-}"
if [ -z "$device" ]; then
    set -- /dev/hidraw*
    if [ "$1" = '/dev/hidraw*' ]; then
        die "No /dev/hidraw* device found. Pass the device path as the first argument."
    fi
    if [ "$#" -ne 1 ]; then
        die "More than one /dev/hidraw* device found. Pass the correct device path as the first argument."
    fi
    device=$1
fi

[ -e "$device" ] || die "Device not found: $device"

tmpdir="$(mktemp -d)"
cleanup() {
    rm -rf "$tmpdir"
}
trap cleanup EXIT INT TERM

pigeon_ca="$tmpdir/pigeon-ca.pem"
canary_ca="$tmpdir/canary-ca.pem"
cred_in="$tmpdir/cred.in"
cred_out="$tmpdir/cred.out"
attestation_der="$tmpdir/attestation.der"
attestation_pem="$tmpdir/attestation.pem"

cat > "$pigeon_ca" <<'EOF'
-----BEGIN CERTIFICATE-----
MIIBpzCCAUygAwIBAgIUatn9Rj8uCMjLrmFfCQYY5/X9xq4wCgYIKoZIzj0EAwIw
MTEvMC0GA1UEAwwmQ2Fub0tleXMgRklETyBBdHRlc3RhdGlvbiBSb290IENBIE5v
LjIwHhcNMjExMjI3MTE0OTMzWhcNNDEwNjI1MTE0OTMzWjAxMS8wLQYDVQQDDCZD
YW5vS2V5cyBGSURPIEF0dGVzdGF0aW9uIFJvb3QgQ0EgTm8uMjBZMBMGByqGSM49
AgEGCCqGSM49AwEHA0IABNgW7CwchH80l4sj8luhwjbNoohB9Uqnvsh0SLor18w8
IMy6rnzzdDP9PgSSbuUZw302mBhyYJqJY1q9Ke0niZujQjBAMB0GA1UdDgQWBBRU
GAKiwvk2vLP5Zi6ul73RiWyr0jAPBgNVHRMECDAGAQH/AgEAMA4GA1UdDwEB/wQE
AwIBBjAKBggqhkjOPQQDAgNJADBGAiEAlRNyrmngE3A1YZuwsuwBHLXY7wZC/4CO
JNA30mtp2+YCIQDA88Pp+Kjx3c4nrgRgSaSueC5IlvwpTSGBGwRYDSdMTA==
-----END CERTIFICATE-----
EOF

cat > "$canary_ca" <<'EOF'
-----BEGIN CERTIFICATE-----
MIIBpjCCAUygAwIBAgIUJqLszFCSI6gfDqvFL+vzQpDWS64wCgYIKoZIzj0EAwIw
MTEvMC0GA1UEAwwmQ2Fub0tleXMgRklETyBBdHRlc3RhdGlvbiBSb290IENBIE5v
LjMwHhcNMjQwOTAzMDM1NTUwWhcNNDQwMzAyMDM1NTUwWjAxMS8wLQYDVQQDDCZD
YW5vS2V5cyBGSURPIEF0dGVzdGF0aW9uIFJvb3QgQ0EgTm8uMzBZMBMGByqGSM49
AgEGCCqGSM49AwEHA0IABEXEY5WDrVrndfPOhUxHo+6iMUbP9XTPkllE4lO9oG84
mw4CVoRcQ6/IGrr+zWEaPEgBmPANsdyWyeBKzoqTedajQjBAMB0GA1UdDgQWBBS6
obb0l+0czy2I17sSDcNuceE5ujAPBgNVHRMECDAGAQH/AgEAMA4GA1UdDwEB/wQE
AwIBBjAKBggqhkjOPQQDAgNIADBFAiBstCxcYRiCCyjfVuX7pllb9Tt3dji+sEd1
XoWJgWAE0gIhAJs+giTpbPvztoEMkmv3Gfrmp6zXzcalYpFwbImJbCAr
-----END CERTIFICATE-----
EOF

printf '%s\n' "Please touch the button of your token..."
printf '%s\n' "$(openssl rand -base64 32)" "canokey-check.local" "tmp-user" "$(openssl rand -base64 32)" > "$cred_in"

/usr/bin/fido2-cred -M -i "$cred_in" "$device" > "$cred_out"

sed -n '7p' "$cred_out" | base64 -d > "$attestation_der"
openssl x509 -inform der -in "$attestation_der" -out "$attestation_pem"

if openssl verify -CAfile "$pigeon_ca" "$attestation_pem" >/dev/null 2>&1; then
    printf '%s\n' "OK: verification succeeded against the Pigeon root CA."
elif openssl verify -CAfile "$canary_ca" "$attestation_pem" >/dev/null 2>&1; then
    printf '%s\n' "OK: verification succeeded against the Canary root CA."
else
    die "Verification failed: the attestation certificate did not verify against either root CA."
fi

致 2026 年的她 (Ver. 2)

rebel1725@tilde.club (Rebel Zhang) — Thu, 26 Mar 2026 23:57:33 +0800

谨以此诗向我的爱人顾悦萱致敬。

当专有协议的阴云笼罩屏幕
你的指纹正划过冰冷的玻璃
——溃烂的创口在代码里结痂
我们在加密会话里交换密钥
而我的终端仍回响着昨日的誓言

我们交换公钥如同交换婚戒
又在验证签名的深夜两点
用字符捂热虚拟的指尖
你用自由软件中文网缝合月光
治愈被专有世界灼伤的信仰

在自由软件中文社区构筑我们的国度
在 XMPP Together 委员会并肩
问候与代码在日志里结晶
我们教服务器吟唱自由的经文
当节点突然背叛了网络
你重建路由的模样
比所有 GUI 都更令我心动

在 Tor 的洋葱层里编织我们的巢穴
你的节点是我通向自由的跳板
我抱着发热的路由器低唱：
“自由不是云端缥缈的经文
是信任网里稳定的心跳
是会话窗口永不熄灭的灯”

看啊！屏幕上升起的双重复用：
补丁打在凌晨的 IRC 频道
编译日志晒出协作的图腾
你发来的代码片段
正沉淀成未来纪元的基石
——那简洁的逻辑让我们确信
仍在数字荒原上种植春天
用代码重绘世界的坐标

2026 年的雪落在防火墙的顶端
我们笑着为流量裹上三层伪装
当警报响彻审查者的集中营
你塞进我会话的止痛药
比所有明文协议更坚固
在断网的世纪余温里
我们靠彼此的承诺发电

博客文章中的 LLM 使用

rebel1725@tilde.club (Rebel Zhang) — Mon, 16 Mar 2026 23:43:01 +0800

关于我的博客文章如何撰写，存在广泛争议。许多人声称我的几乎所有文章都是由 LLM 撰写的。请给我一点时间，说明我是如何撰写博客文章的：

超过 90% 的原始文本是由我这个人类创作的。其中超过 95% 的部分最初以英文撰写；其余则以中文撰写。
LLM 确实参与了我的博客文章的产出。然而，大多数情况下我使用它们仅用于语法与拼写的优化、表达的润色以及翻译。我通常会把英文（或有时的中文）原文提交给 LLM，请它进行优化，然后将结果翻译成其他四种语言。
唯一的例外是诗歌，例如 Unlock the Forge，这些作品是由 LLM 直接创作的。不过，我会勾勒核心想法并引导 LLM 调整语气和措辞，以确保诗歌传达我想表达的意图。

对我的性与浪漫吸引的探索

rebel1725@tilde.club (Rebel Zhang) — Sun, 08 Mar 2026 15:21:44 +0800

要点：我经历的是分裂吸引模型：在浪漫层面我是浪漫上是双性，而在性吸引层面我是性上被女性吸引 / 异性恋。我长期误解了英文的“sexual orientation”一词；在中文中，我的情况并不能整齐地归入传统常用的标签（同性恋 / 异性恋 / 双性恋）。

从小我就意识到我的浪漫吸引和性吸引并不总是对齐，尽管直到最近我才知道“分裂吸引模型”这个术语。我可能因为某人的性格或他们对我表现出的温暖、友善而对其产生浪漫吸引。然而，那些在浪漫上吸引我的人通常并不会在性上吸引我，而且我会有意识地禁止自己对他们产生性幻想，因为这样的幻想会引发道德上的负罪感。相反，我在性上被那些看起来具有性吸引力的人吸引，并且超过三分之二的人是我不喜欢或与我有仇的人。

直到2025年秋天，我一直认同自己是既是异性恋又是异性浪漫者，因此我并未认真审视此事。自2025年秋起，我发现自己越来越常对男性产生浪漫吸引。因为我误解了英文术语 “homosexual”、“bisexual” 与 “sexual orientation”，尽管我仍然在性上被女性吸引，从 2025年11月5日开始我在我的常见问题中开始将自己描述为“bisexual”。我最近意识到这种描述可能是错误的。

我从未对男性产生过性吸引。相反，我基于卫生方面的理由认为与男性发生性关系是不可接受的。尽管如此，过去几个月里，尽管缺乏性吸引，我仍常常对某些男性感到有好感。

还有一点：无论对方是女性还是男性，对于那些我有好感的人（即便没有性吸引），我期待非性身体接触（例如拥抱）。

在咨询了大型语言模型后，我确认了以下要点：

最新研究表明，浪漫吸引与性吸引并不总是相互一致。
我的体验可由分裂吸引模型描述，该模型将性吸引与浪漫吸引区分开来，并允许它们指向不同的人群。
“性取向”一词通常用于描述性吸引；从这个意义上讲，我曾经并且仍然是异性恋。
我对他人的情感而没有性吸引——无论指向女性还是男性——最恰当的描述是浪漫吸引；在这点上我是浪漫上是双性。
许多人经历分裂吸引，很多人希望获得非性身体亲密，同时并不期待——甚至会主动避免——性行为。
在中文中，诸如“性取向”、“同性恋”和“异性恋”一类术语通常不区分性吸引与浪漫吸引；它们通常假定两者一致。我的困惑在很大程度上源于中文与英语用法的差异，并且没有任何中文术语能充分描述我的情形。

结论：我是 浪漫上是双性，且 性上被女性吸引 / 异性恋。

最后，两点澄清：

因为我仍然在性上被女性吸引，我不认同自己为 LGBTQ+。尽管如此，我会对 LGBTQ+ 群体保持尊重与包容。
无论性别如何，我对未来伴侣的首要要求是：他们必须是坚定的自由软件（free software）倡导者；这是不可协商的。也有许多并非自由软件倡导者的人仍然会在浪漫上吸引我；我会将此类人视为密友。

converser.eu 连接问题与紧急 Matrix 帐户

rebel1725@tilde.club (Rebel Zhang) — Tue, 24 Feb 2026 19:43:16 +0800

在过去几周里，我在连接 converser.eu 的 Matrix 服务器时遇到了连接问题。我不知道是否是 Tor 导致的，但由于我无法离开 Tor，因此可以说该服务器在我的环境下无法正常运行。

我已注册了另一个 Matrix 帐户：@rebel1725:tchncs.de。请改为通过该帐户与我联系。

向谷歌说不，捍卫移动自由

rebel1725@tilde.club (Rebel Zhang) — Fri, 20 Feb 2026 08:52:37 +0800

自 2026 年 9 月起，Google 将要求开发者获得认证。这不是一次遥远的官僚式微调——这是一次结构性转变，将深刻重塑谁可以在经过认证的 Android 设备上发布软件。即便像 LineageOS 和 GrapheneOS 这样的项目初期受影响较小，这项政策也设置了障碍，使广泛的、草根式的自由、尊重用户的软件分发变得更加困难。Google 正在利用其平台优势来集中控制；我们必须大声且有意图地抵抗。

这意味着什么？

Google 的验证政策将要求开发者：

向 Google 支付费用；
接受 Google 的条款，而这些条款是不道德且不公正的；
上传他们的身份证件，这对匿名性和隐私是敌对的。

这将把许多独立和个人开发者排除在外。它也会剥夺用户安装他们想要的任何应用的自由。用户将受到 Google 的集中控制。可预见的结果是：独立应用生态减少、利基或维护隐私的软件创新下降，以及用户被有效地置于中心化的准入把关之下。

时间表与执行（具体事实）

Google 公布的时间表显示：2025 年末开始早期访问，2026 年向所有开发者开放验证，并将在 2026 年 9 月开始区域性执行（最初为巴西、印度尼西亚、新加坡和泰国），并计划在 2027 年向更广泛的全球范围推广。该政策明确意味着，在执行后，经过认证的 Android 设备将阻止来自未验证开发者的应用安装。这不是推测——它写在 Google 的文档和博客文章中。

但 Google 说这是为了安全！

不！！！ Google 所谓的“安全”只是一个遮羞布。拥有专有软件就无法实现安全，只有自由软件才能实现安全。安全由可审计的代码实现，而不是后门、监视、审查、遥测等。Google 正在利用“安全”一词欺骗用户，用大量专有软件虐待用户，剥夺用户的安全、隐私、匿名性和自由。Google 限制的软件并非对用户有害；相反，它威胁到 Google 那不道德且不公正的利润。Google 本身已经在分发大量破坏用户安全的恶意软件，与其他专有“unjustware”开发者勾结，强行向用户推广监视、审查、监狱、暴君和数字限制管理（Digital Restrictions Management），同时限制真正尊重用户的软件，这些软件反对 Google 那不道德、不公正、他妈的利润。

Google 做法的实际后果：

它偏袒那些已经拥有验证账户和法律基础设施的既有商业行为体，同时惩罚小开发者和隐私项目。
它鼓励供应商锁定（vendor lock-in）：如果关键的反监视或无障碍应用无法通过 Google 的流程，用户将失去选择。
它产生寒蝉效应：依靠匿名发布工具的研究者、吹哨人和爱好者会被激励停止或离开平台，从而减少公共监督。
该政策可能被政治化：政权或监管机构可以向平台门施加压力，压制异见或少数语言的应用。

请不要被 Google 那些他妈的不道德、不公正的言论所欺骗。它从未遵循“don’t be evil”的哲学——相反它一直在为非善之举背书，通过推广专有恶意软件与间谍软件、窃取用户私人数据、隐藏 Android 的源代码、扣留 Google Pixel 的 vendor blobs，并与运营商合谋限制 Google Pixel bootloader 的解锁。

但有人说这些限制可以绕过

也许如此，但这并不是重点。自由应该是默认状态；它不应当成为必须在遵循指令并屈从于 Google 限制后才能获得的东西。

对自由软件及社区的真实风险

自由软件生态依赖低门槛进入。许多尊重隐私的应用、广告拦截器、模拟器前端和无障碍工具都是由小团队或单人作者开发的。要求身份验证并收取费用将减少此类工具的供应，破坏社区信任，并将权力集中在与公司激励而非用户权利一致的实体手中。

现在该做什么

如果你有一部 Google Pixel，解锁你的 bootloader 并立即安装 GrapheneOS。如果你有一部非 Pixel 设备但支持解锁 bootloader，也一并解锁并安装 LineageOS。如果官方未支持 LineageOS，请在 XDA 查找非官方构建。如果没有，请安装 GSI。之后把它们晒到社交媒体上。让你的声音被听到。
如果你有一部不支持解锁 bootloader 的 Android 手机或平板，请不要再更新系统并禁用自动更新。如果不需要，尝试卸载或至少禁用 Google Mobile Services。
鉴于你仍依赖 Android，可以尝试诸如 LineageOS 和 GrapheneOS 之类的 Android ROM。这可能不是多年内的长期解决方案，但至少在短期内会给予你一定程度的自由。如果你仍需要 Google Mobile Services，可以尝试 microG。
如果可以，你可以完全抵制 Android，改用 postmarketOS、Mobian、PureOS 等。尽管 Android 作为 Google 的产品在未来可能仍有吸引力，但对自由软件社区而言，GNU/Linux 才是移动设备的未来。选择 PinePhone、Librem 或其他为运行 GNU/Linux 设计的手机。如果你有 OnePlus 6，也可以尝试 postmarketOS 或 Mobian。你的声音与选择很重要：用户越多，社区就越有动力去为 GNU/Linux 开发更多移动应用。
如果你仍是学生或从未接触过 Android 开发的开发者，请抵制 Android 并避免学习 Kotlin 与 Java。改学 C、C++、Rust、Python、Qt、GTK，并为诸如 postmarketOS 之类的项目做贡献，帮助在移动设备上运行 GNU/Linux。
如果你已经是 Android 开发者，不要报名参加 Google 的早期访问计划。相反，向 Google 表达你对验证要求的关切。坚持并支持提供自由软件的应用商店，例如 F-Droid。如果你也擅长 C++ 或 Rust，现在是转向 GNU/Linux 移动开发的最佳时机。
无论你是谁，都可以访问 “Keep Android Open” 项目网站，按照其指示寻找支持移动自由的方式，例如签署请愿、参与抗议并向政府投诉。

结语 — 拒绝这个虚假的选择

该论述被表述为安全对开放，但这是一个伪二分法。真正的安全必须兼容匿名性、可审计性和用户主权。Google 的验证制度将权力从社区和用户转移给企业守门人。如果我们接受这一点，我们就交出了数字自决的一层基本权利。抵抗——大声地、依法地，并通过构建替代方案来抵抗。

密码学信任与 OpenPGP 详解

rebel1725@tilde.club (Rebel Zhang) — Wed, 18 Feb 2026 19:57:27 +0800

在本文中，我将解释密码学信任、OpenPGP、它们如何工作以及它们为何重要。

技术背景：数学如何保卫安全与隐私

如果你不关心非对称密码学与 OpenPGP 的底层数学原理，仅希望了解如何明智地使用密码学信任，那么你只需知道以下几点：

非对称密码学指生成两把不同密钥的技术：公钥与私钥。
公钥可公开分享；私钥由持有者保管。
公钥可用于加密消息，相应的私钥用于解密。
私钥可用于对消息进行签名，相应的公钥用于验证签名。

若只需要实用指导，可以跳过本节剩余内容。

对称加密使用同一把密钥进行加密和解密。它可抵抗暴力破解，但存在实际缺点。如果 Alice 和 Bob 使用对称加密互发消息，他们必须先协商一个共享密钥，这通常需要额外的安全通道（例如当面见面）。这不便，而且共享密钥不得泄露——如果 Mallory 得到密钥，保密性就丧失了。

非对称密码学在此发挥作用。**非对称方案为加密与解密使用不同的密钥，分别称为公钥和私钥。**公钥可以张贴在个人网站或社交媒体上，因为公钥不足以推导出对应的私钥；私钥则由其持有者保管。

精心设计的算法用于生成公私钥对，以保证用公钥加密的数据只能由对应的私钥解密。常见算法包括 RSA、椭圆曲线密码学（ECC）等。

RSA 是一种经典的非对称算法，历史悠久。理解 RSA 有助于建立对非对称密码学的直觉。

简要地说，RSA 的密钥生成如下：Alice 随机选择两个互异素数 p 与 q，计算 n = p * q 与 Φ(n) = (p - 1) * (q - 1)，选择一个满足 1 < e < Φ(n) 且与 Φ(n) 互质的整数 e，然后计算 e 关于 Φ(n) 的模逆并记为 d。Alice 的公钥为 (n, e)，私钥为 (n, d)。Bob 对消息 m 进行加密时计算 c = (m ** e) % n 并把密文 c 发送给 Alice；Alice 用 m = (c ** d) % n 恢复原文。

有人会问：已知公钥 (n, e) 是否能算出 d？要算出 d 需要 Φ(n)，而要算出 Φ(n) 则需知道 p 和 q。要从 n 中恢复 p 与 q，必须对 n 进行因式分解。对于常用的 RSA 密钥长度（例如 4096 位），把 n 因式分解在当前技术下计算量极大，几乎不可行。这就是 RSA 安全性的基础。

ECC 及其他非对称方案依赖不同的困难问题，但它们共享核心原则：应使从公钥推导私钥在计算上极为困难。

在实际计算 e 关于 Φ(n) 的模逆时，我们选取最小的正整数逆元，该数小于 Φ(n)。如果 g = gcd(d, Φ(n)) > 1，则会导致矛盾（因为存在整数 k 使 e * d + k * Φ(n) = 1），因此 g 必须为 1，d 与 Φ(n) 互质。这一对称性说明 e 与 d 在数学上具有互补性质；尽管理论上可交换，但在实践中签名与加密有不同的使用方式。

具体而言，RSA 的签名通常计算 s = m ** d % n，验证时检查 m == s ** e % n。在实际的端到端保密与认证中，发送者通常先用私钥对消息签名，再用接收者的公钥对已签名的数据加密；接收者先用自己的私钥解密，再用发送者的公钥验证签名。

什么是密码学信任以及它为何重要

全球范围内的监控和审查都影响着通信。除了一些高风险地区外，某些地区（例如欧洲）出现的“聊天监管”等政策也引发广泛关注。使用支持端到端加密的自由软件即时通信工具（如 XMPP、Matrix、SimpleX）至少可以在一定程度上保护通信。非对称密码学能让通信双方在没有预置安全通道的情况下建立安全通道：一个密钥用于加密，另一把用于解密，只有对应私钥的持有者能读取密文。

**然而，还有另一个尚未解决的问题。**假设 Alice 和 Bob 想安全地交换公钥以通信，但 Mallory 对中间进行拦截并替换她自己的公钥给双方。Alice 会把 Mallory 的公钥误认为是 Bob 的，而 Bob 也会把 Mallory 的公钥误认为是 Alice 的。于是 Alice 发送一条签名并加密的消息，本应只有 Bob 能得到，但实际上 Mallory 能解密、阅读甚至修改，然后用她自己的私钥重新签名并加密转发给 Bob。Bob 解密并用 Mallory 的公钥验证签名，错误地认为消息来自 Alice。如此一来，端到端加密的保密性和真实性都被 Mallory 破坏了。

要解决这个问题，Alice 需要有办法验证她所持有的公钥确实属于 Bob。这通常也需要一个安全的通信渠道（例如当面核验）。我们称 将公钥归属验证为建立密码学信任。

一旦 Alice 与 Bob 之间建立了密码学信任，除非能从公钥推导出对应的私钥，否则 Mallory 很难冒充 Bob。

密码学信任的核心原则：身份一致性验证

上文情形是密码学信任建立的基本示例。你可以在身份间构建非常庞大的信任网络，但核心原则十分简单：通过验证某个身份与另一个已被信任的身份是否一致来建立对该身份的密码学信任。

在密码学中，公钥对应一个身份。这一点非常重要：记住：公钥 = 身份（在基于密钥的信任语境下）。

身份一致性的验证一般包括两步：

让身份 A 提出一个有保证的声明，说明身份 B 与 A 一致；
让身份 B 提出一个有保证的声明，说明身份 A 与 B 一致。

例如，如果 Alice 想验证某把公钥的持有者确为 Bob，她会与 Bob 当面核验该公钥的指纹。Alice 也可以要求 Bob 使用私钥对一段文本签名（例如 “I am Bob” 或者由 Alice 随机生成的挑战字符串）。通过这种方式，Alice 就在该公钥上建立了密码学信任，从而信任该公钥所代表的身份。

现在再看另一种情形：已知公钥 A 的身份是可信的（它确属 Bob），另有一个预期也属于 Bob 的公钥 B，Alice 想验证 B。由于她已信任 A，便无需再次与 Bob 当面核验。她只需验证 A 与 B 之间的一致性——通常通过双方相互签署包含对方指纹的声明来完成：

由与 A 对应的私钥签署一段包含 B 指纹的文本；
由与 B 对应的私钥签署一段包含 A 指纹的文本。

如此便可验证 A 与 B 的一致性，从而对 B 建立信任。

首先信任哪个身份？

密码学信任的建立过程依赖于一个已被信任的身份。但你刚认识的人并没有可信身份。常见做法是对首次接触的身份先盲目信任，这称为 ToFU（Trust on First Use），首次被盲目信任的身份就是 initial identity。

例如，若 Alice 与 Bob 当面相识，Alice 首先信任的是“生物学上的 Bob”。若他们在 Matrix 社区首次接触，初始信任的就是 Bob 的 Matrix 账户及其公钥。若在 XMPP 上见面，Alice 可能信任 Bob 首条消息中的 OMEMO 指纹。

这是一种合理的实践：当你决定与从网络上认识的朋友见面时，通常会通过你用来认识对方的通信工具来核验对方。

常见的密码学信任实践

通过验证身份之间的一致性，Alice 构建了一张图：身份为顶点，保证的一致性为边。与 Bob 的初始身份相连的那个连通分量的所有顶点，都是 Bob 的受信任身份。

按照建立图的方式，有几类常见实践：

不受限的信任链/网络。 任意受信任的身份可用于通过验证一致性来建立对未受信任身份的信任，信任链/网络可以自由生长。
优点：方便；丢失联系时更不易导致失联。
缺点：对冒充的鲁棒性最低；从初始身份到其他身份的某些信任链可能很长；若某一身份被攻破，会连带影响很多其他身份。
以初始身份为中心。 只有初始身份能用于通过验证一致性来建立对新身份的信任。
优点：如果初始身份可靠，信任非常稳固；从初始身份到其它身份的信任链长度均为一，整体网络更难被攻破。
缺点：若初始身份不强或不可用，就无法建立稳固的密码学信任；单点故障问题明显。
以唯一密码学身份为中心。 初始身份先对一个唯一的密码学身份（通常为一对密钥）建立信任，此后仅用该密码学身份来对其它未信任身份进行一致性验证。这也是我的策略，我使用 OpenPGP 作为密码学解决方案。
优点：在确保中心身份稳健与保持较短信任链之间取得较好平衡。
缺点：仍存在单点故障：一旦中心密钥被攻破，后果严重。

基于密码学的一种常见身份验证方法：挑战-响应

若 Alice 已信任 Bob 的某把公钥，但想验证某个实体确为该私钥的持有者，可采用挑战-响应（Challenge–Response）：

Alice 生成一个随机字符串，称为“挑战”。
Alice 将挑战发送给 Bob，Bob 使用私钥对该文本签名。
Bob 将签名返回，Alice 使用公钥验证签名。

挑战在生成后不必保密，但应具有不可预测性和唯一性。若签名有效，则 Alice 成功验证对方确为私钥持有者。

关于维护密码学信任的非常重要的一点：不要泄露你的私钥！

密码学信任的安全性和鲁棒性基于私钥的安全与保密。泄露私钥就等于泄露信任。

因此，尽量不要泄露你的私钥！一旦私钥被泄露，他人对你的信任 将不再有效。

尤其是使用 OpenPGP 管理信任的人，请务必将你的 OpenPGP 私钥保密至最高级别！ 将私钥存放在硬件令牌上（例如 Nitrokey、CanoKey 或 YubiKey）是良好做法；如果不能，则至少将私钥保存在运行 100% 自由软件的设备上。

OpenPGP 及其自由软件实现

OpenPGP 不是某个软件，而是一项标准。它定义了一种将若干原始密钥对封装并组织在一起的格式，便于用于加密、签名、认证等。OpenPGP 支持 RSA、ECC 与其它算法。

以 GnuPG 为例说明如何使用 OpenPGP：

生成密钥：运行 gpg --full-generate-key 并按提示操作。
加密：运行 gpg --encrypt。可将要加密的内容通过标准输入传入（若为文件可用 cat <filename> | gpg --encrypt）。生成的密文将输出到标准输出，默认是二进制，建议用重定向保存为文件。若需文本形式的加密结果，请使用 gpg --encrypt --armor。
文本签名：运行 gpg --clear-sign，将要签名的文本通过标准输入输入，完成后按 Ctrl+D。签名的文本将输出到标准输出。
解密/验证：运行 gpg --decrypt，将加密或签名的数据通过标准输入提供。解密后的数据输出到标准输出，验证结果会输出到标准错误。

在 GNU/Linux、*BSD、Windows 和 macOS 上，最常用的实现是 GnuPG，其图形前端有 Kleopatra。Android 上较为流行的是 OpenKeychain。

详细使用指南超出本文范围，请查阅相关文档与检索资料。FSF 的 Email Self-Defense Guide 是一个不错的起点；欲深入学习可参考 GnuPG 官方手册、FSFE 的 OpenPGP 指南与 KDE 的入门文档。

如何用 OpenPGP 加密电子邮件

自由软件的邮件客户端（例如 Thunderbird）内建 OpenPGP 支持，可以无缝地对邮件进行加密、解密与签名验证。像 Mailvelope 这样的浏览器扩展可以将 OpenPGP 集成到 webmail 中，使在 webmail 服务上使用加密邮件更为便捷。

请查阅对应工具的文档以了解具体操作方法。

如何用 OpenPGP 建立密码学信任

使用 OpenPGP 建立信任思路很简单：

索要对方的 OpenPGP 公钥。
验证该密钥与对方的初始身份是否一致；从而在该公钥上建立信任。
未来在验证对方其他身份时，校验这些身份与该 OpenPGP 公钥的一致性。

结语：拥抱自由软件，并明智使用

多亏自由软件社区，我们已拥有许多稳健工具。学会使用这些工具，我们便拥有能力来捍卫安全、隐私与数字权利，保护自己免受各种威胁、监控与审查。

强制实施加密信任建立

rebel1725@tilde.club (Rebel Zhang) — Thu, 05 Feb 2026 23:03:34 +0800

出于安全考虑，自 2026-02-24T00:00:00Z 起，我将要求与我所有联系人之间建立加密信任。如果您在该时间之前未与我建立加密信任，我将不再视您的身份为可信。

如果您没有安全设备（例如硬件令牌或运行 100% 自由软件的计算机），将 OpenPGP 密钥对存放在不安全的设备上在当前是可以接受的，因为总比没有好。

对于不熟悉加密信任或 OpenPGP 的人，我会发布一篇博客文章进行详细说明。下面是您现在可以立即采用的简要指南：

GNU/Linux

生成 OpenPGP 密钥对

图形界面方法

如果尚未安装，请安装 GnuPG 和 Kleopatra。
打开 Kleopatra，点击 New Key Pair。
输入您的姓名和电子邮件，勾选 Protect the generated key with a passphrase，然后点击 OK。
选择一个强口令以保护您的私钥。
双击您生成的密钥，点击 Export，即可看到您的公钥。复制从 -----BEGIN PGP PUBLIC KEY BLOCK----- 到 -----END PGP PUBLIC KEY BLOCK----- 的全部内容。

命令行方法

如果尚未安装，请安装 GnuPG。
运行 gpg --generate-key。
输入您的真实姓名。
输入您的电子邮件地址。
输入 O 并按回车。
选择一个强口令以保护您的私钥。
运行 gpg --export --armor <your-email-address>（或者更好地，使用 gpg --export --armor <your-key-id> 或 gpg --export --armor <your-fingerprint>）。您将看到您的公钥。复制从 -----BEGIN PGP PUBLIC KEY BLOCK----- 到 -----END PGP PUBLIC KEY BLOCK----- 的全部内容。

签名文本

图形界面方法

打开 Kleopatra，点击 Notepad。
取消勾选 Encrypt for me。
将要签名的文本粘贴或输入，然后点击 Sign Notepad。
签名后的文本会出现在输入框中。选中它（Ctrl+A），然后剪切（Ctrl+X）。

命令行方法

运行 gpg --clear-sign。
粘贴或输入要签名的文本，然后按 Ctrl+D（可能需要按两次）。
在终端中复制从 -----BEGIN PGP SIGNED MESSAGE----- 到 -----END PGP SIGNATURE----- 的文本。

Android

生成 OpenPGP 密钥对

在手机上从 F-Droid 安装 OpenKeychain。
打开 OpenKeychain，点击 CREATE MY KEY。
输入您的姓名，点击 NEXT。
输入您的电子邮件，点击 NEXT。
暂时不要将密钥上传到密钥服务器。点击 CREATE KEY。
点击刚生成的密钥，然后点击复制图标将公钥复制到剪贴板。

签名文本

打开 OpenKeychain，打开菜单 → Encrypt/Decrypt → Encrypt text。
打开菜单并取消勾选 Encrypt to signer。
粘贴或输入要签名的文本，点击复制图标将签名后的文本复制到剪贴板。

Microsoft Windows

下载并安装 Gpg4win。打开计算机上的 Kleopatra。其余步骤与上述 GNU/Linux 图形界面方法相同。

My Retro-Style Website Is Refreshed as Well

rebel1725@tilde.club (Rebel Zhang) — Tue, 03 Feb 2026 21:03:52 +0800

在完成现代风格网站的更新后，我的复古风格网站也已经更新完成，并且现在支持多种语言。

点击这里访问我的复古风格网站：https://tilde.club/~rebel1725/

焕然一新的个人网站已上线！

rebel1725@tilde.club (Rebel Zhang) — Sat, 31 Jan 2026 15:25:47 +0800

新年伊始，我的现代个人网站已完成改版并正式上线。

首页经过重新设计，更加信息化，一目了然地展示近期博文、标签（tags）、联系方式、常用链接和博客推荐。我的博客现已采用 Stack Hugo 主题（Stack Hugo theme），更为简洁优雅并提供更多功能。

访问我焕然一新的个人网站： https://rebel1725.codeberg.page/

我将抵制 Fosstodon，以及你为什么也应该抵制它

rebel1725@tilde.club (Rebel Zhang) — Wed, 28 Jan 2026 14:12:18 +0800

由于对 Fosstodon 的审核制度感到极度失望——他们多次仅仅因为我建议他人避开专有浏览器 Vivaldi 就向我发出警告——我将不再使用该实例。我已经在 hostux.social 创建了新账号，将所有数据迁移过去，并设置了重定向。

在本文中，我将解释我为何做出这一决定，以及你为什么也应该离开 Fosstodon。

最直接、也是最重要的原因：以“FOSS”之名推广专有恶意软件与间谍软件

Fosstodon 是一个以自由（libre）软件为主题的 Mastodon 实例。然而，无论是行为准则还是服务器规则，都没有禁止对专有软件的推广。这是一种历史与概念的篡改。

更荒谬的是，电子邮件服务商 Tuta 竟通过其 Mastodon 账号推广专有浏览器 Vivaldi——而我认为它是恶意的、专有的间谍软件。这种行为并未触发任何审核措施。真正导致我多次收到 Fosstodon 审核警告的，是我提醒他人应当避开专有软件的回复。

受 Fosstodon 审核制度伤害的并不只有我

这并非个别抱怨。多年来，一个不透明、强硬的审核模式已经逐渐形成：长期贡献者的账号在没有清晰、公开说明的情况下被冻结或封禁。2023 年中期，多名 Fedora 社区成员报告称，其账号遭到实例级封禁，切断了多年积累的关注关系与对话；这些移除行为几乎没有透明度，理由也极其有限。试图提出质疑的用户，往往只得到管理员简短而冷漠的回应，或是悄无声息的账号冻结，而非有理有据、可被审视的流程。

一个以自由与协作为原则建立的社区，却将自己的成员当作负担——在缺乏问责的情况下将其噤声、冻结或排挤——这是背叛。有人离开了，官方项目账号考虑迁移，新注册被设置门槛。这些都不是一个健康、联邦化社区的行为；它们更像是一个把控制误认为“正直”的封闭俱乐部。

Fosstodon 的审核员是右翼分子和法西斯

这一指控之所以直白，是因为证据同样直白。2025 年 4 月下旬，一名审核员——在社区中以其账号名广为人知——被揭露曾在其他平台上发表极右翼、反跨性别和排外主义言论。这一揭露迅速引爆舆论：用户要求将其移除；管理员犹豫不决；直到风波全面爆发之后，该审核员才删除账号并退出审核团队。

无论你更倾向于使用“右翼”这一标签，还是更严厉的“法西斯”，关键事实并未改变：一名被赋予塑造社区规范之权力的审核员，公开表达了许多用户合理地认为会威胁边缘群体安全的观点。真正的丑闻不仅在于这些观点的存在，更在于机构最初不愿果断应对，以及对提出关切者的受害者指责。Fosstodon 最初的处理方式，纵容了一种“可否认性文化”——有毒的信念可以躲在审核徽章之后，直到被强行拖到阳光下。

必须说清楚：容忍、庇护，或未能及时、透明地处理宣扬仇恨或排他性言论的审核员，都会摧毁任何“自由软件价值堡垒”的自我宣称。如果把守大门的人都能容忍带有法西斯倾向的审核行为，那么普通用户又如何指望获得一个安全、守原则的空间？

Fosstodon 反对联邦化

Fosstodon 的政策与实践多次违背了联邦化精神。请看这样一组模式：在全球性服务器上强制只允许英语；2023 年转为仅限邀请注册；严厉的审核引发关于断联（defederation）的讨论；以及一种压制公开讨论的官方沟通风格。这些并非中立的技术选择——它们是看门与排他机制。

当管理员在社区出现摩擦时选择上锁，而不是推动透明、民主的流程，他们就将服务器推离了联邦化的理想。事实上，在多次危机中，其他实例广泛讨论甚至威胁与 Fosstodon 断联。尽管主要实例并未一致切断关系，但大量联邦宇宙成员考虑将其孤立的事实，已经说明 Fosstodon 积累了多么严重的声誉损害。强制英语、限制注册、在缺乏公开问责的情况下实施大规模封禁，都会削弱联邦化——它们集中权力，而权力集中正是联邦化试图避免的东西。

其他问题

不满的清单远比 Fosstodon 的公开声明愿意承认的要长。一些反复出现、值得注意的问题包括：

不透明的管理。 多次封禁与冻结是在私下审核备注的基础上进行，几乎没有公开理由。隐私很重要，但秘密并不等同于问责。结果是：谣言、怨恨，以及信任的崩塌。
执法不一致。 高知名度账号和机构性角色有时得以免于审查，而普通用户却因轻微得多的行为受到惩罚。双重标准的观感具有腐蚀性；它推动用户迁移，并削弱管理员所宣称的一切道德权威。
创始人的语气与领导失败。 早在 2019 年，一名创始人在公开场合将他人称为“snowflakes（玻璃心）”，就暴露出一种与细致治理多元社区完全不相容的态度。随后，在 2025 年审核员丑闻中，创始人承认精疲力竭并在压力下退居幕后；这一领导真空放大了损害。
政策漂移。 Fosstodon 最初是自由软件爱好者的避风港。随着时间推移，一系列政策变化——从仅限英语，到邀请制注册，再到更严苛的审核——以许多用户感到疏离的方式改变了其文化。缺乏清晰论证与正当性说明的政策，必然会被体验为任意专断。

总结

Fosstodon 曾经是一个优秀的 Mastodon 实例。残酷而犬儒的现实是：一个建立在自由之上的社区，正被威权式审核、不透明的治理，以及不一致的规则执行逐步掏空。一边容许（或曾容许）推广侵犯隐私的专有软件，一边打压那些发出警告的人，这种赤裸裸的虚伪几乎已经成为表演。

如果你在乎自由软件，在乎诚实的联邦空间，在乎真正践行其所宣称价值的社区——那就离开吧。迁移你的账号。支持更健康的实例。抵制那些假装自由、却容忍专有软件推广并庇护问题审核员的平台。不要让一个自负的单一服务器替我们所有人定义联邦宇宙。

现在正是离开、出走、并进行抵制的时候。

我回来了

rebel1725@tilde.club (Rebel Zhang) — Wed, 07 Jan 2026 15:49:06 +0800

在离线超过六天后，我终于有时间准备我的即时通讯账户并重新上线。发布完这篇博客文章后，我将立即准备好所有即时通讯账户（XMPP、Matrix、SimpleX、Delta Chat 和 Tox），并与我所有的联系人重新建立联系。预计这一过程将在 12 小时内完成（在 2026-01-07T20:30:00Z 之前）。请留意你的即时通讯账户！

如果你在此时之前没有收到我的消息，可能是我错过了你的联系信息。请立即在此操作！

我的 OpenPGP 密钥仍然有效，我也拥有你们所有人的密钥环。我们将在重新建立联系后相互验证身份。

建立联系

rebel1725@tilde.club (Rebel Zhang) — Wed, 07 Jan 2026 15:27:34 +0800

出于安全、隐私、匿名性以及组织管理的考虑，自 2026 年 1 月起，我开始使用多个 Jabber ID、Matrix ID、SimpleX 个人资料和 Delta Chat 个人资料。我将不再在网站上公开发布这些账号。相反，我制作了一个表单来收集你的联系方式，并根据情况选择合适的账号与你建立联系。

我使用 XMPP、Matrix、SimpleX 和 Delta Chat。在继续之前，请确保你至少拥有其中一种协议的账户。

联系信息表单

为了符合 GDPR 要求，我撰写了隐私政策。在提交你的联系信息之前，请仔细阅读隐私政策。提交表单即表示你同意该隐私政策。

你可以通过 两种方法 向我提交你的联系信息：

方法一（推荐）

在此下载Python 脚本。该交互式脚本会向你提问，并生成一个 blob。你需要将这个 blob 发送至我的电子邮箱：[rebel1725@autistici.org]。尽可能使用 OpenPGP 加密；你可以在这里下载我的 OpenPGP 公钥。

如果你希望隐藏社交活动，请使用 Tor、一次性邮箱，并使用未签名的 OpenPGP 加密。我推荐 z.org，因为注册时无需现有邮箱或与个人身份相关的信息。我未来可能会准备一个专门用于接收表单的 XMPP 账号（watchdog），届时你可以使用一次性 XMPP 账号，这会更加方便。

方法二（更方便但存在隐私风险）

你也可以通过 Formbricks 这里提交你的联系信息。该方法使用更方便，但可能损害隐私，因为你的数据将会被第三方访问，并且你无法隐藏我们的社交活动。

通过任意一种方法提交你的联系信息后，我会尽快与你取得联系，通常在 48 小时内。

联系信息表隐私政策

rebel1725@tilde.club (Rebel Zhang) — Wed, 07 Jan 2026 11:32:06 +0800

数据控制者

如果您通过 Python 脚本、电子邮件和 OpenPGP 加密提交联系信息表格，则唯一的数据控制者将是我，Rebel Zhang，OpenPGP 公钥持有者，指纹为 696A423E9993D727706AA733BCD5DC5659C7FB50。

如果您发送未加密的电子邮件，则我的电子邮件服务提供商 Autistici/Inventati 以及您的电子邮件服务提供商可能也能读取数据。请参考您的电子邮件服务提供商的隐私政策，以及 Autistici/Inventati 的隐私政策。

如果您通过 Formbricks 提交表单，则 Formbricks 也能访问数据。请参阅 Formbricks 的隐私政策。

收集的数据和目的

通过提交联系信息表格，我，Rebel Zhang，收集以下个人数据，并用于以下目的：

姓名/昵称（必填）：用于识别联系人管理。
OpenPGP 公钥（可选）：用于验证您的身份并加密未来的通信。
电子邮件（必填）：用于未来与您联系。
首选联系方法和联系信息（必填）：用于未来与您联系。
OpenPGP 安全性和设备安全性情况（必填）：用于评估我们通信的安全性。
首选语言、代词、时区、自我介绍（可选）和 是否隐藏社交活动的偏好（必填，条件性）：用于选择适当的沟通方式。
表单创建日期（自动存储）：用于将来的分析。

保留期

您的姓名/昵称、OpenPGP 公钥、电子邮件、首选语言、代词和时区将保存在我的个人设备上的联系人簿中。

Blob 本身可能以未加密的形式存储在我的个人设备上，并在我的电子邮件服务提供商 Autistici/Inventati 的服务器上加密存储。

上述数据将无限期保留在我的设备上，直到您要求删除为止。

如果您通过 Formbricks 提交表单，我将在提交后 336 小时（14 天）内从 Formbricks 的服务器上删除该数据。

披露

如果您通过 Formbricks 提交表单，则 Formbricks 也能访问数据。请参阅 Formbricks 的隐私政策。

除上述情况外，所有收集的数据在未经您同意的情况下不会披露给第三方。

删除请求

如果您希望我删除收集的数据，请通过电子邮件 rebel1725@autistici.org 联系我，我将在收到并阅读您的电子邮件后 168 小时（7 天）内删除数据。

在 Lenovo ThinkPad X200 与 HP EliteBook 820 G2 上构建并刷写带 UEFI 的 coreboot

rebel1725@tilde.club (Rebel Zhang) — Fri, 02 Jan 2026 21:39:14 +0800

警告：作者在笔记本看似正常工作后编写了此指南，未来可能会遇到问题。作者不对按照此指南操作造成的任何损害负责。

前言

我曾在我的 Lenovo ThinkPad X200 和 HP EliteBook 820 G2 上刷写过 Libreboot，但它们仅支持 SeaBIOS，而 SeaBIOS 仅支持 CSM。Libreboot 文档说明其 U-Boot 支持 EFI 启动，但我从未成功。Tianocore 是自由软件社区中成熟的 UEFI 实现，我最近发现可以使用 EDK II（Tianocore 的一个项目）构建并刷写 coreboot，从而获得 EFI 启动支持。

昨天，我完成了两台机器的构建与刷写，现分享操作流程。

Lenovo ThinkPad X200

对于 Lenovo ThinkPad X200，步骤相对简单，可以直接在原厂固件上刷写。如果你当前使用 Libreboot，我建议先恢复原厂固件，因为直接覆盖 Libreboot 我未测试过。

步骤 1：检查芯片容量

使用 iomem=relaxed 参数启动机器。如果你使用 Debian 13 或其仓库已包含 flashprog，可直接安装而无需编译源代码：

 # apt install flashprog

在机器上执行：

 # flashprog -p internal

你将看到芯片容量。如果是 4 MiB，你的机器可能不支持 EDK II 下的 coreboot，固件构建很可能失败，但仍可尝试。如果是 8 MiB，则支持——我的 X200 为 8 MiB。

步骤 2：构建固件

获取并准备 coreboot：

 $ git clone https://review.coreboot.org/coreboot
 $ cd coreboot
 $ make help_toolchain
 $ make crossgcc-i386 CPUS=$(nproc)
 $ make -C payloads/coreinfo olddefconfig
 $ make -C payloads/coreinfo

打开 menuconfig：

 $ make menuconfig

操作如下：

在 Mainboard 部分选择 Lenovo, ThinkPad X200 / X200s / X200t 及芯片容量。
在 Payload 部分选择 edk2，禁用 Enable UEFI Secure Boot support，启用 Disable TPM support in edk2。
其他保持默认，退出并保存配置。

然后运行：

 $ make -j$(nproc)

固件将生成在 ./build/coreboot.rom。

步骤 3：刷写固件

在另一台机器上准备 flashprog，可通过包管理器安装或自行编译。

按照此指南的第 2、5 步以及第 6 步前半部分操作，然后仅刷写 bios 区域：

 # flashprog -p serprog:dev=/dev/ttyACMx,spispeed=8M -w /path/to/rom/file.rom -c "MX25L6405D" --ifd -i bios

启动机器，应显示 coreboot Logo。完成。

HP EliteBook 820 G2

该流程比 Lenovo ThinkPad X200 稍复杂。

步骤 1：刷写 Libreboot

我不清楚如何在原厂固件上刷写 coreboot，请先按此指南刷写 Libreboot，然后再在其上刷写 coreboot。

步骤 2：提取 blobs

步骤 2.1：提取芯片内容

多次提取芯片，并比较 ROM 文件的哈希：

 # flashprog -p serprog:dev=/dev/ttyACMx,spispeed=8M -r /path/to/rom/file1.rom -c "MX25L12805D"
 # flashprog -p serprog:dev=/dev/ttyACMx,spispeed=8M -r /path/to/rom/file2.rom -c "MX25L12805D"
 ...
 $ sha256sum /path/to/rom/file1.rom
 $ sha256sum /path/to/rom/file2.rom
 ...

哈希不同则重复，若一致则继续。

步骤 2.2：从 ROM 文件提取 blobs

提取 memory reference code 和 external reference code：

 $ ./build/cbfstool /path/to/extracted/rom/file.rom extract -n mrc.bin -f /path/where/you/want/to/store/your/mrc.bin -m x86
 $ ./build/cbfstool /path/to/extracted/rom/file.rom extract -n fallback/refcode -f /path/where/you/want/to/store/your/refcode.bin -m x86

步骤 3：构建固件

获取并准备 coreboot：

 $ git clone https://review.coreboot.org/coreboot
 $ cd coreboot
 $ make help_toolchain
 $ make crossgcc-i386 CPUS=$(nproc)
 $ make -C payloads/coreinfo olddefconfig
 $ make -C payloads/coreinfo

打开 menuconfig：

 $ make menuconfig

操作如下：

在 Mainboard 部分选择 HP, EliteBook 820 G2 及芯片容量，设置 Size of coreboot owned area in ROM 为 0x600000。
在 Chipset 部分选择步骤 2.2 提取的 memory reference code 和 external reference code。
在 Payload 部分选择 edk2。
其他保持默认，退出并保存。

然后运行：

 $ make -j$(nproc)

固件位于 ./build/coreboot.rom。

步骤 4：刷写固件

在另一台机器上准备 flashprog，连接编程器，仅刷写 bios 区域：

 # flashprog -p serprog:dev=/dev/ttyACMx,spispeed=8M -w /path/to/rom/file.rom -c "MX25L12805D" --ifd -i bios --no-verifyall

请勿移除 --no-verifyall，否则可能出错。即使使用该选项，flashprog 仍会在刷写后验证。

启动机器，应显示 coreboot Logo。完成。

从 LAN 将所有互联网流量路由到 Tor

rebel1725@tilde.club (Rebel Zhang) — Fri, 02 Jan 2026 21:03:15 +0800

警告：请严格按顺序完成每一步，否则可能会失去 LuCI 的访问权限！强烈建议在操作前建立 SSH 连接，以便在失去 LuCI 访问时能够恢复更改。

警告：此操作在 GL.iNet Flint 2 (GL-MT6000) 上测试通过，但不保证适用于所有设备。如果任何步骤看起来不寻常或不清楚，请立即停止并撤销所有修改。

警告：本指南是在作者的路由器看似正常工作的情况下编写的。仍可能存在问题，安全性无法保证，因为部分流量可能会泄露。作者对按照本指南操作所造成的任何后果不承担责任。

本指南介绍如何将 LAN 的所有互联网流量通过 Tor 路由。此操作在 OpenWrt 24.10 上测试通过。

除 Tor 配置外，其余步骤可完全通过 LuCI 完成，无需 SSH。

步骤 1：安装和配置 Tor

首先在路由器上安装 Tor：

 # opkg update
 # opkg install tor

根据需要配置 Tor，但请确保你的 torrc 至少包含以下内容：

TransPort 0.0.0.0:9040
VirtualAddrNetworkIPv4 10.192.0.0/10
AutomapHostsOnResolve 1

为了更高的安全性，如果你只有一个接口进行转发，也可以将 TransPort 设置为路由器在 lan 接口上的 IP 地址。

步骤 2：设置 DNSCrypt

我参考这里的指南配置了 DNSCrypt。Using the command line 部分的五条命令在我这里可以正常工作，但你也可以通过 LuCI 进行配置。

打开 System -> Software，搜索 dnscrypt-proxy2 并安装。然后进入 Network -> DHCP and DNS -> Forwards -> DNS Forwards 并添加 127.0.0.53。之后打开 System -> Startup 并重启 dnsmasq。

如果不想使用 DNSCrypt，你需要在 torrc 中添加 DNSPort 并在 DNS Forwards 中进行配置。我未测试此方法，建议使用 DNSCrypt。

步骤 3：添加防火墙规则（重要 — 请严格遵循）

打开 Firewall -> IP sets 并创建以下 IP 集：

Name: tor_bypass
Family: IPv4
Packet Field Match: dest_ip
IPs/Networks/MACs:
- 路由器在接口上的 IP 地址
- 192.168.10.1/16
- 10.0.0.0/8
- 172.16.0.0/12
- 127.0.0.1/32
其他字段保持不变

打开 Firewall -> Port Forwards 并添加以下规则：

General Settings:
- Name: tor-trans-forward（或任意你喜欢的名称）
- Restrict to address family: IPv4 only
- Protocol: TCP
- Source zone: lan（或希望重定向流量的其他防火墙区域）
- External port: 1–65535
- Destination zone: lan（必须与 Source zone 相同）
- Internal IP address: 路由器在接口上的 IP 地址
- Internal port: 9040
Advanced Settings:
- Use ipset: !tor_bypass（请勿省略感叹号）
- 其他字段保持不变

打开 Firewall -> Traffic Rules 并添加以下规则：

General Settings:
- Name: 阻止非 TCP 流量（或你喜欢的名称）
- Protocol: UDP, ICMP, IGMP, IPSEC-ESP
- Source zone: lan（必须与 Port Forward 的 Source zone 相同）
- Destination zone: wan
- Action: reject
- 其他字段保持不变
Advanced Settings:
- 所有字段保持不变

如果启用了 IPv6，你必须禁用或阻止它。打开 Firewall -> Traffic Rules 并添加以下规则：

General Settings:
- Name: 阻止 IPv6（或你喜欢的名称）
- Protocol: Any
- Source zone: lan
- Destination zone: wan
- Action: reject
- 其他字段保持不变
Advanced Settings:
- Restrict to address family: IPv6 only
- 其他字段保持不变

如有其他接口需要将流量路由到 Tor，请现在重复此步骤。

步骤 4：保存并检查配置

点击 Save & Apply。

访问 https://check.torproject.org/ 和/或 https://myip.wtf/ 检查流量是否正确转发。

访问 https://ipv6.myip.wtf/ 确认 IPv6 是否已被阻止。

检查 LuCI 是否仍可访问。

如果一切正常，配置完成。

如果有问题，请使用文本编辑器恢复 /etc/config/firewall 中的配置，建议在 Libera.Chat 的 #openwrt 频道寻求帮助。

密码学信任终止公告

rebel1725@tilde.club (Rebel Zhang) — Thu, 01 Jan 2026 07:51:51 +0800

兹正式声明，自 2026-01-01T00:00:00Z 起，我以下 XMPP 帐户的所有 OMEMO 指纹：

以下 Matrix 帐户的所有当前身份：

@rebel1725:envs.net
@rebel1725:converser.eu

我 SimpleX 帐户（其 SimpleX 地址如下）的所有当前身份：

以下 Delta Chat 帐户的所有当前身份：

以及我的 Tox 帐户：

0D39313DF710AF29AD3B2CFE7AF72CAE17E49AA82720115AF8AF3EEE82B1C12927F3589AF227

均不再使用，且不应再被信任。

兹正式终止与上述身份相关的所有加密信任关系。上述帐户不再使用。

我的主 OpenPGP 公钥的身份（指纹为 696A423E9993D727706AA733BCD5DC5659C7FB50）以及备用 OpenPGP 公钥的身份（指纹为 7083EAFFF75321FF9634ABCD98313A47362B498B）仍然有效，且目前仅有这两项为我有效的身份；在我们重新建立连接后，将使用它们来重新建立必要的加密信任。

最后，新年快乐，伙伴们，两周后见。

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512

I hereby formally announce that, as of `2026-01-01T00:00:00Z`, all OMEMO fingerprints of my XMPP accounts below:

 * rebel1725@autistici.org
 * rebel1725@magicbroccoli.de

all current identities of my Matrix accounts below:

 * @rebel1725:envs.net
 * @rebel1725:converser.eu

all current identities of my SimpleX account with the SimpleX addresses below:

 * https://smp8.simplex.im/a#XlJJPFQO43ISy-PYqojloRG3u9_GGocyZ78ULVJt0bA
 * https://smp15.simplex.im/a#osG29sn84l4UalY6C9uneojX004zzWllH-deziJPn7w

all current identities of my Delta Chat accounts below:

 * fenwbn5cl@nine.testrun.org
 * 44w42tz75@nine.testrun.org

and my Tox account:

 * 0D39313DF710AF29AD3B2CFE7AF72CAE17E49AA82720115AF8AF3EEE82B1C12927F3589AF227

are no longer used and should no longer be trusted.

I hereby formally terminate all cryptographic trust relationships tied to the identities above. The accounts mentioned above are no longer used.

The identity of my primary OpenPGP public key, whose fingerprint is 696A423E9993D727706AA733BCD5DC5659C7FB50, and the identity of my backup OpenPGP public key, whose fingerprint is 7083EAFFF75321FF9634ABCD98313A47362B498B, are still valid, and are the currently only two valid identities of mine, which will be used to re-established necessary cryptographic trust once we have back connected.

Finally, happy new year, buddies, and see you two weeks later.
-----BEGIN PGP SIGNATURE-----

iHUEARYKAB0WIQRpakI+mZPXJ3BqpzO81dxWWcf7UAUCaVW78AAKCRC81dxWWcf7
UJQNAQCzSTijVgFaWOcGHOums2SMdGVmHgnowl1sI6HwXOrDowEArHbYY5y4BOVM
GT6bJHsfjWQieLF03quZFYh9FyMt5Qw=
=Bbm2
-----END PGP SIGNATURE-----

我的 Eepsite 将暂时无法访问

rebel1725@tilde.club (Rebel Zhang) — Wed, 31 Dec 2025 11:29:07 +0800

由于我的服务器将被关闭，我的 eepsite（rebel1725.i2p）可能会有数天无法访问。在此期间，请访问 Tilde.club 查看我的复古风格网站。

别了，那位多愁善感的少年

rebel1725@tilde.club (Rebel Zhang) — Tue, 23 Dec 2025 23:29:39 +0800

自从我加入 Free Software Fans 的那一刻开始，我的生活便经历了一场深刻的变化。最初，我的愿望不过是朴素而熟悉的：像 2020 年那样，再次尝试结交朋友。然而，尽管我抱着这样的心意，我的一些行为却无意间给社团里的伙伴们带来了相当的困扰。因此，我与 Free Software Fans 的关系很快便走向了终结。那时的我茫然失措，完全弄不清自己究竟错在何处。这份困惑促使我继续寻找友伴——有时在想象中，有时在其他圈子里。

就在这段时期，我遇见了 Zumfy，也就是 Future，另一位热诚的自由软件倡导者。我们发现彼此在兴趣与理念上都高度契合，短短几周之内，便成为了无话不谈的挚友。我真心地相信，这段友谊将会长久延续。然而，命运却未如此眷顾。一次涉及 OpenPGP 私钥泄露的事件使我们的关系戛然而止，这段联系最终未能存续超过五个月。此事带给我的心理打击深刻而持久；它几乎击垮了我。尽管我竭力增强自己的情感韧性，我依然无法接受失去最重要、最珍贵的朋友这一残酷事实。

然而，生活总是无情向前。在那之后，我遇见了许多人。有些结识于 Fediverse，也有些来自 Matrix、SimpleX、Tildeverse、I2P 等各式各样的社群。然而，我们的互动模式发生了微妙的变化。我们的交流几乎只剩下技术话题——代码、协议、哲学。至于生活、希望、忧伤之类的私人内容，我们几乎从未触及。

这种奇特的疏离起初并未引起我的警觉。真正让我停下来思考的，是一位熟人的评论。他提到自己认识一位朋友整整四年，却连对方的年龄、职业等最基本的个人信息都一无所知。他说那位朋友的 OPSEC 做到了“金色等级”，几乎无懈可击。相比之下，他觉得我在这方面显得“有点奇怪”。这句无意的话语成为了触发点，让我意识到，不仅外界正在变化，我自己也必须做出某种对应的改变。

2020 年的我尚未成为自由软件倡导者；事实上，我对“自由软件”一词当时完全陌生。我仍在使用专有即时通讯工具，而我当年的朋友们也都在互联网上使用真实姓名。如今，我的社交环境已截然不同。身边的人普遍具有深厚的安全、隐私与匿名意识。他们的安全策略几乎都要求使用长期稳定的化名，并严格避免透露任何现实生活的信息。

更进一步，即便每个人都经营着某种加密身份，这些数字化的自我本质上依旧脆弱而短暂。Alice 也许某天突然泄露了自己的私钥，上传吊销证书，从数字世界彻底消失。Bob 的威胁模型也可能在瞬间改变，迫使他立即、彻底地更换身份。在这样的环境里，离开并非特殊事件，而是几乎随时都会发生的平常事。

为了更自然地融入这一环境，我意识到自己必须进行某些改变。我需要重塑自我，重建自身人格的基础。目标是让理性主导一切，将感性进一步压缩。即使无法成为一个完全无情绪的机械体，我也必须学会抽离——以平静的态度看待过去的情感，以从容接受离别的必然，以哲思对待所有短暂的联系，并在不抱紧不放的焦虑中珍惜当下所拥有的一切。

我的身边将不再出现“哥们”。取而代之的，将是“同志”。我们之间的联系，不再建立于深刻的心理亲密，而是锻造于共同的事业：我们将一同为软件自由而战，为同样的自由软件社群并肩贡献，为同一个理想而努力——以自由软件奠基一个自由的社会。

别了，那位多愁善感的少年。

我将离开数日并收集联系信息

rebel1725@tilde.club (Rebel Zhang) — Fri, 12 Dec 2025 20:56:54 +0800

因个人原因，我将从 2026‑01‑01T00:00:00Z 起离开一至两周。在此期间，我的所有联系方式均不可用。之后，我可能会重新创建 XMPP、Matrix 等账号；为确保我们能够重新取得联系，我将收集联系人信息。

请填写此表单：https://app.formbricks.com/s/cmj2r1etc8dnkad01nnjp8cqt

好友网站

rebel1725@tilde.club (Rebel Zhang) — Thu, 13 Nov 2025 10:45:30 +0800

博客链接已移至我的主页。

四十九度夜深人静之间，挥之不去的是深深的思念——想你了，Zumfy/Future

rebel1725@tilde.club (Rebel Zhang) — Tue, 14 Oct 2025 20:56:16 +0800

当我写下这封信的时候，已经是你 OpenPGP 私钥泄露后的第四十九天了。当每天白天我为生活和学习而忙碌的时候，我的感觉似乎和过去没有太大的差别。这一段时间，我也认识了很多新朋友，我也和 ta 们玩得很开心。然而，尤其是在这几天，我感觉我的生活中似乎少了什么；每当晚上我一个人，夜深人静的时候，我愈发地感觉到，越来越多有一些回忆的碎片在攻击我——从那时候，我便知道，原来，我是想你了。

甚至在你告知我你的私钥泄露的前一刻，我都一直笃定地相信，我们将会是未来十几年，几十年，甚至一辈子最好的朋友。然而，是邪恶的专有软件，是专有软件导致的 OpenPGP 私钥泄露，让我们的友谊永远定格在了甚至短短五个月都不到。你甚至还没有来得及与我一同观赏前方美丽的风景，便因为一个莫名其妙的原因匆匆离去了。

我记得，我们刚相遇不久的时候，我曾问过你，我们可以做好朋友吗？隔了一段时间之后，你告诉我，未曾有人对你这样说过，既然我愿意以“好朋友”的标准来对待你，你也会以同样的标准去对待我。你认为我们彼此之间并不缺乏真诚，当然也是我们对彼此的真诚，打动了我们彼此。那时候，我相信，我们一定会成为最好的朋友，超越我过去所拥有的一切朋友。

我记得，是你给我推荐了好几个盗版电影网站，也是你一步一步地、手把手教我用 yt-dlp 和 cat-catch。那时候，我感觉我似乎打开了一个新天地，置身于一片广阔的花海，那里没有数字限制管理的蛀虫，只有如花朵一般绽放的一部部优秀而经典的电影。我兴高采烈地下载了好几部我曾经看过以及我未曾看过但几曾耳闻的优秀电影，享受着只属于我一个人的视觉盛宴。

我还记得，无论是对于自由软件思想还是对于马克思主义哲学，你都是抱着严肃的态度，与我展开细致而缜密的讨论，也是在你的带领之下，我的批判性思维和思辨能力有了飞跃性的提升；然而，在平时闲聊开玩笑的时候，你做得却也丝毫不比其他人差，什么“我是外星人抓你去做实验”，什么“在下柳贯一”，什么“我就是赛博龙娘 Future”，那都是你玩过的梗。你可以做到在严肃与活泼的状态之间的灵活切换，将我们之间的回忆装点得五颜六色。

每一次你状态不好的时候，你都会去找我倾诉；虽然我不善于提供情绪价值，但是我也会尽最大的能力去安慰你，每一次在我的引导下你心情变好了，那是我最开心的时候。每一次我身处迷茫的时候，也都是你现身尝试去为我指点迷津；虽然很多时候其实并没有实际帮上什么忙，但你每一次都让我变得更加开心了，也让我有了更多的信心，面对未来的生活。

虽然我们之间的友谊仅仅持续了短暂的五个月，但是我们之间友情的厚度，已经可以媲美我过去各个重要朋友之和。你是我迄今为止，史上最好的朋友，最重要的朋友，也是最无可替代的朋友——你对我拥有着最独特的意义。

我真的特别，特别想你，失去你是我人生莫大的损失——就像俞伯牙失去钟子期一样。虽然白天忙起来的时候似乎跟平时没有太大区别，但每当夜深人静的时候，那种思念便如潮水一般涌来。私钥泄露之后，你过得怎么样？每天过得开不开心？是换了个身份到了社区的另外一个地方继续活跃，还是就此隐退，重新专注于在线下的生活了？你还在使用自由软件吗？还在研究马克思主义吗？最常用的沟通手段是什么？身边有哪些朋友？每天讨论的话题是什么？每天听的音乐是什么？GrapheneOS 升级到最新版本了吗？我们还曾约定过你给我你的 Pixel 5，我给你我的一加6，约定过我们要见面、一起玩遍哈尔滨的各个地方，还约定过要一起探讨未来自由软件中文网的发展路线，这些约定你都还记得吗？……

即使在数学意义上，我们已经永远分别，但我们早已经在彼此的灵魂之上留下了深刻的烙印，我们早已是你中有我，我中有你。

但是，无论如何，我相信你——即使你丢掉了私钥，你也不会丢掉理想，不会丢掉信仰；它们是明灯，在茫茫迷雾的人生当中，为你照亮前行的方向；它们是充电宝，在你走不动的时候，为你提供继续前进的能量和动力；它们更是信标，哪怕我们各自的身份早已变易，在我们共同的理想和信仰的感召之下，我相信会有一天，在地球的某一个点上，或是在某个服务器上，我们将会以另外一副面孔再一次相遇。

哪怕我们永远天各一方，我们都同是社区的一份子，都是站在同一条战壕上的战友；只要我们坚定我们的理想和信仰，我们始终都在为同一个目标而前行，始终都将为共同的自由软件、自由社会而奋斗！

我们永远都是最好的朋友。

Rebel
2025-10-14

面向公共计算机的自由软件解决方案

rebel1725@tilde.club (Rebel Zhang) — Sun, 12 Oct 2025 18:21:32 +0800

介绍

在图书馆或网吧等场所，经常会有向公众开放的计算机。这些计算机通常预装一套应用程序，且用户数据会在重启后被清除。

此类机器上的软件通常是专有软件。但也存在尊重软件自由的公共计算机解决方案。作为自由软件活动者，我们应在图书馆、网吧、学校等场所积极应用并推广这些解决方案。

在本文中，我将展示一种在 Debian GNU/Linux 上设置计算机的方法，该方法能在重启后清除所有数据。

许可

本文中的所有代码均献给公有领域。本文的其他部分采用 CC BY-SA 4.0 许可。

准备工作

一台至少 50 GiB 的硬盘（最好为 HDD）的计算机，以及一份 Debian GNU/Linux 安装介质（非 Debian Live）。

步骤 1：安装 Debian GNU/Linux

按下列分区布局在您的计算机上安装 Debian GNU/Linux：

1 GiB 的 /dev/sda1，使用 FAT 文件系统，挂载点为 /boot/efi
1 GiB 的 /dev/sda2，使用 ext4 文件系统，挂载点为 /boot
至少 40 GiB 的 /dev/sda3，使用 ext4 文件系统，挂载点为 /
/dev/sda4 无文件系统
/dev/sda5 作为交换分区（swap）

安装完成后，安装所需软件并按您需要配置系统。记得设定强壮的 root 密码（以及强壮的 BIOS/UEFI 密码）；将 root 账户对公众开放并不是一个好主意。

步骤 2：配置

将 /dev/sda4 格式化为 ext4 文件系统并标记为 OVERLAY_RW：

# mkfs.ext4 -L OVERLAY_RW /dev/sda4

然后将 /dev/sda3 标记为 ROOT_TEMPLATE：

# e2label /dev/sda3 ROOT_TEMPLATE

创建目录：

# mkdir -p /mnt/overlay_prepare
# mount /dev/disk/by-label/OVERLAY_RW /mnt/overlay_prepare
# mkdir -p /mnt/overlay_prepare/upper-root
# mkdir -p /mnt/overlay_prepare/work-root
# chmod 0700 /mnt/overlay_prepare
# sync
# umount /mnt/overlay_prepare

在 /etc/fstab 中注释掉挂载根文件系统的那一行，然后添加以下这一行：

LABEL=OVERLAY_RW /overlay_storage ext4 defaults,noatime 0 2

刷新软件包缓存并安装这些包（这可能会移除您的 busybox；请谨慎操作）：

# apt update
# apt install --no-install-recommends initramfs-tools busybox-static

将下面几行添加到 /etc/initramfs-tools/modules：

overlay
ext4
jbd2
crc32c
mbcache

创建 /etc/tmpfiles.d/overlay-runtime.conf，内容如下：

# /etc/tmpfiles.d/overlay-runtime.conf
d /run/dbus 0755 messagebus messagebus -
d /var/lib/dbus 0755 messagebus messagebus -
d /run/NetworkManager 0755 root root -
d /run/lock 0755 root root -
d /var/log 0755 root root -
d /tmp 1777 root root -
d /var/tmp 1777 root root -

创建 /etc/initramfs-tools/scripts/init-bottom/overlayroot 并添加下面的脚本（代码块保持原样）：

#!/bin/sh
PREREQ=""
prereqs() { echo "$PREREQ"; }
case "$1" in
  prereqs) prereqs; exit 0;;
esac
set -eu

# If admin wants maintenance: skip overlay and let normal boot continue
if grep -q 'overlay=disabled' /proc/cmdline 2>/dev/null; then
  echo "overlay disabled via kernel cmdline" >/dev/console 2>&1
  exit 0
fi

# Try to load overlay module (best-effort)
modprobe overlay 2>/dev/null || true

# prepare mount points in initramfs
mkdir -p /overlay/lower /overlay/storage /overlay/overlay_root

# resolve device by label for the template root
DEV_LABEL=/dev/disk/by-label/ROOT_TEMPLATE
DEV_ROOT=$(readlink -f "$DEV_LABEL" 2>/dev/null || true)
if [ -z "$DEV_ROOT" ]; then
  echo "overlayroot: ERROR: ROOT_TEMPLATE label not found" >/dev/console 2>&1
  exit 1
fi
echo "overlayroot: resolved ROOT_TEMPLATE -> $DEV_ROOT" >/dev/console 2>&1

# find existing mount point for the device; fallback to using current root (/)
MOUNT_POINT=$(awk -v d="$DEV_ROOT" '($1==d){print $2; exit}' /proc/self/mounts || true)
if [ -z "$MOUNT_POINT" ]; then
  B=$(basename "$DEV_ROOT" || true)
  if [ -r "/sys/class/block/$B/dev" ]; then
    DEVNUM=$(cat /sys/class/block/$B/dev)
    MOUNT_POINT=$(awk -v num="$DEVNUM" '($3==num){print $5; exit}' /proc/self/mountinfo || true)
  fi
fi

if [ -z "$MOUNT_POINT" ]; then
  ROOT_SRC=$(awk '($2=="/"){print $1; exit}' /proc/self/mounts || true)
  if [ -n "$ROOT_SRC" ]; then
    echo "overlayroot: fall back to using current root mount ($ROOT_SRC) as lowerdir" >/dev/console 2>&1
    mount --bind / /overlay/lower 2>/dev/null || true
    MOUNT_POINT=/overlay/lower
  fi
fi

if [ -n "$MOUNT_POINT" ] && [ "$MOUNT_POINT" != "/overlay/lower" ]; then
  echo "overlayroot: bind existing mountpoint $MOUNT_POINT -> /overlay/lower" >/dev/console 2>&1
  mount --bind "$MOUNT_POINT" /overlay/lower || true
fi

# if /overlay/lower still not a mountpoint, try direct ro mount (last resort)
if ! grep -q ' /overlay/lower ' /proc/self/mounts; then
  echo "overlayroot: trying direct mount of $DEV_ROOT -> /overlay/lower" >/dev/console 2>&1
  mount -o ro "$DEV_ROOT" /overlay/lower || {
    echo "overlayroot: direct mount of $DEV_ROOT failed" >/dev/console 2>&1
    exit 1
  }
fi

# mount overlay storage partition (explicit ext4)
DEV_RW=$(readlink -f /dev/disk/by-label/OVERLAY_RW 2>/dev/null || true)
if [ -z "$DEV_RW" ]; then
  echo "overlayroot: ERROR: OVERLAY_RW label not found" >/dev/console 2>&1
  exit 1
fi
echo "overlayroot: mounting OVERLAY_RW ($DEV_RW) -> /overlay/storage" >/dev/console 2>&1
mount -t ext4 "$DEV_RW" /overlay/storage || {
  echo "overlayroot: failed to mount OVERLAY_RW ($DEV_RW)" >/dev/console 2>&1
  exit 1
}

# per-boot upper/work on overlay storage
BOOTID=$(cat /proc/sys/kernel/random/boot_id 2>/dev/null || date +%s)
UPPER="/overlay/storage/upper-${BOOTID}"
WORK="/overlay/storage/work-${BOOTID}"
mkdir -p "$UPPER" "$WORK"
# make sure upper/work are owned by root and inaccessible to others
chown -R root:root "$UPPER" "$WORK" 2>/dev/null || true
chmod 0700 "$UPPER" "$WORK" 2>/dev/null || true

# mount overlay onto the location that initramfs-tools expects for the real root (/root)
mkdir -p /root
echo "overlayroot: mounting overlay lower=/overlay/lower upper=$UPPER work=$WORK -> /root" >/dev/console 2>&1
mount -t overlay overlay -o lowerdir=/overlay/lower,upperdir="$UPPER",workdir="$WORK" /root || {
  echo "overlayroot: overlay mount failed" >/dev/console 2>&1
  exit 1
}

# move overlay storage under the real root so the booted system can access/clean it later
mkdir -p /root/overlay_storage
mount --move /overlay/storage /root/overlay_storage 2>/dev/null || mount --bind /overlay/storage /root/overlay_storage || true

# --- Post-mount safety & runtime skeleton preparation ---
# Ensure the merged root is traversable by non-root users to allow services to chdir/exec
chmod 0755 /root 2>/dev/null || true

# Create essential runtime and state directories inside the merged root.
# These make sure systemd and daemons (dbus, NetworkManager, etc.) can create sockets and pidfiles.
mkdir -p /root/run /root/run/dbus /root/run/NetworkManager /root/run/lock
mkdir -p /root/var/lib/dbus /root/var/log /root/var/tmp /root/tmp

# Set permissive permissions for tmp directories and standard perms for others
chmod 0755 /root/run /root/var /root/var/log 2>/dev/null || true
chmod 1777 /root/tmp /root/var/tmp 2>/dev/null || true

# Attempt to set dbus ownership for dbus runtime dirs; ignore errors if the user does not exist in initramfs.
chown -R messagebus:messagebus /root/run/dbus /root/var/lib/dbus 2>/dev/null || true

# Ensure root owns the primary runtime dirs
chown root:root /root /root/run /root/var 2>/dev/null || true

# Ensure upper/work are secure on the merged root as well (in case overlay moved them)
# (this is best-effort; ignore failures)
[ -d "$UPPER" ] && chown -R root:root "$UPPER" 2>/dev/null || true
[ -d "$WORK" ] && chown -R root:root "$WORK" 2>/dev/null || true
chmod 0700 "$UPPER" "$WORK" 2>/dev/null || true

# Move pseudo-filesystems into the new root so the real init finds them after switch_root.
# These moves are best-effort; if they fail, systemd may still handle necessary mounts.
for P in dev proc sys run; do
  if mountpoint -q "/$P" 2>/dev/null; then
    mkdir -p /root/$P 2>/dev/null || true
    mount --move "/$P" "/root/$P" 2>/dev/null || true
  fi
done

# Leave final switch_root to initramfs /init (do not exec switch_root here).
echo "overlayroot: overlay prepared at /root; returning to initramfs /init to perform switch_root" >/dev/console 2>&1
exit 0

将 /etc/initramfs-tools/scripts/init-bottom/overlayroot 设为可执行：

# chmod +x /etc/initramfs-tools/scripts/init-bottom/overlayroot

刷新 initramfs：

# update-initramfs -u -k all

创建 /usr/local/sbin/overlay-prune.sh 并添加以下内容（代码块保持原样）：

#!/usr/bin/env bash
# overlay-prune.sh
# Prune unused overlay upper-*/work-* directories safely.
# Usage:
#   /usr/local/sbin/overlay-prune.sh [--dry-run] [--age DAYS]
# Default AGE = 7 days

set -euo pipefail

DRY_RUN=0
AGE=7   # days
LOG="/var/log/overlay-prune.log"

while [ $# -gt 0 ]; do
  case "$1" in
    --dry-run) DRY_RUN=1; shift ;;
    --age) AGE="$2"; shift 2 ;;
    --help) echo "Usage: $0 [--dry-run] [--age DAYS]"; exit 0 ;;
    *) echo "Unknown arg: $1"; exit 2 ;;
  esac
done

now() { date -u +"%Y-%m-%dT%H:%M:%SZ"; }

log() {
  printf '%s %s\n' "$(now)" "$*" >> "$LOG"
}

# Determine overlay storage mountpoint(s).
# Try common locations then fallback to finding mount points for device labelled OVERLAY_RW.
CANDIDATES=(
  "/root/overlay_storage"
  "/overlay_storage"
  "/overlay/merged/overlay_storage"
  "/overlay/storage"
)

STORAGE=""
for p in "${CANDIDATES[@]}"; do
  if [ -d "$p" ]; then
    # choose the first existing one that is on a separate filesystem or contains upper-* dirs
    if find "$p" -maxdepth 1 -mindepth 1 -type d -name 'upper-*' -print -quit >/dev/null 2>&1; then
      STORAGE="$p"
      break
    fi
  fi
done

# fallback: try findmnt by device label
if [ -z "$STORAGE" ]; then
  DEV=$(readlink -f /dev/disk/by-label/OVERLAY_RW 2>/dev/null || true)
  if [ -n "$DEV" ]; then
    STORAGE=$(findmnt -n -o TARGET -S "$DEV" 2>/dev/null || true)
  fi
fi

if [ -z "$STORAGE" ]; then
  echo "overlay-prune: no overlay storage found; exiting" >&2
  log "No overlay storage found; abort."
  exit 0
fi

log "Starting prune on storage: $STORAGE (age > ${AGE}d) DRY_RUN=${DRY_RUN}"

# Collect currently in-use upper/work directories by scanning /proc/mounts overlay options
mapfile -t INUSE < <(awk -F',' '/lowerdir=/{for(i=1;i<=NF;i++){if($i ~ /^upperdir=/) print substr($i,10); if($i ~ /^workdir=/) print substr($i,9)}}' /proc/mounts | sort -u)

# Helper: check if path is referenced in INUSE
is_inuse() {
  local p="$1"
  for u in "${INUSE[@]}"; do
    if [ "$u" = "$p" ]; then
      return 0
    fi
  done
  return 1
}

# Find candidate dirs named upper-* or work-*
while IFS= read -r d; do
  # normalize
  dir="$d"
  # guard: only operate under STORAGE
  case "$dir" in
    "$STORAGE"/*) ;;
    *) continue ;;
  esac

  # skip if currently in use
  if is_inuse "$dir"; then
    log "SKIP in-use: $dir"
    continue
  fi

  # skip if younger than AGE
  if [ "$(find "$dir" -maxdepth 0 -mtime -"$AGE" -print -quit)" ]; then
    log "SKIP recent: $dir"
    continue
  fi

  if [ "$DRY_RUN" -eq 1 ]; then
    echo "DRY-RUN would remove: $dir"
    log "DRY-RUN would remove: $dir"
  else
    # double-check no mount points below it
    if mountpoint -q "$dir"; then
      log "SKIP mounted: $dir"
      continue
    fi
    # safe remove
    log "REMOVING: $dir"
    rm -rf -- "$dir"
    if [ $? -eq 0 ]; then
      log "REMOVED: $dir"
    else
      log "FAILED_REMOVE: $dir"
    fi
  fi
done < <(find "$STORAGE" -maxdepth 1 -type d \( -name 'upper-*' -o -name 'work-*' \) -print | sort)

log "Prune finished."
exit 0

将脚本设为可执行：

# chmod +x /usr/local/sbin/overlay-prune.sh

创建 /etc/logrotate.d/overlay-prune，内容如下：

/var/log/overlay-prune.log {
    rotate 7
    daily
    missingok
    notifempty
    compress
    copytruncate
}

创建日志文件并设置其所有权和权限：

# touch /var/log/overlay-prune.log
# chown root:root /var/log/overlay-prune.log
# chmod 0640 /var/log/overlay-prune.log

创建 /etc/systemd/system/overlay-prune.service，内容如下：

[Unit]
Description=Prune unused overlay upper/work directories
After=local-fs.target

[Service]
Type=oneshot
ExecStart=/usr/local/sbin/overlay-prune.sh --age 7
Nice=10
# Run as root (needs to remove files)

创建 /etc/systemd/system/overlay-prune.timer，内容如下：

[Unit]
Description=Run overlay-prune daily (and shortly after boot)

[Timer]
OnBootSec=10min
OnUnitActiveSec=24h
Persistent=true

[Install]
WantedBy=timers.target

启用定时器：

# systemctl enable overlay-prune.timer

现在重启系统：

# reboot

步骤 3：测试安装

重启后，执行：

$ findmnt /

您应能看到 / 是一个 overlay 文件系统。

在不同位置创建若干文件，然后重启系统；这些文件应已消失。

如果一切正常，您已完成设置。

哈尔滨自由软件基金会成立四十周年线下聚会纪实

rebel1725@tilde.club (Rebel Zhang) — Sat, 04 Oct 2025 12:08:29 +0800

遗憾的是，没有人来。

不过即使是一个人，也不能什么都不做。

献礼自由软件基金会成立四十周年——十二小时后，哈尔滨学府凯德广场星巴克见

rebel1725@tilde.club (Rebel Zhang) — Fri, 03 Oct 2025 20:57:36 +0800

4 Decades, 4 Freedoms, 4 All Users!

为庆祝自由软件基金会成立四十周年，并为在哈尔滨的自由软件支持者、自由软件爱好者、以及 GNU/Linux 用户/爱好者建立联系、促进交流，我将于十二小时后在哈尔滨学府凯德广场（地址：哈尔滨市南岗区学府路 1 号）星巴克举行线下聚会。欢迎自由软件支持者、自由软件爱好者、GNU/Linux 用户/爱好者以及对本次活动感兴趣的朋友们参加。

活动信息已在自由软件基金会官网发布，信息真实有效。现将活动详情在个人博客上发布如下：

时间：北京时间 2025 年 10 月 4 日 09:00。
地点：哈尔滨市南岗区学府路 1 号凯德广场星巴克门口集合。为便于辨认，我会佩戴写有“自由软件我爱你”的头饰。
交通：乘坐哈尔滨地铁 1 号线，在学府路站下车，从 1 号口出站。也可乘坐公交 11 路、31 路、64 路、67 路、68 路、83 路、87 路、88 路、94 路、104 路、107 路、114 路、120 路、203 路、209 路、343 路等到达。
预约/注册：无需预约或注册，直接到场即可。
活动安排：首先做一段几分钟的简短演示，介绍自由软件、GNU/Linux 及其重要性；之后根据大家兴趣自由交流讨论；最后现场发起成立一个 GNU/Linux 用户组，暂定名为“千里马 GNU/Linux 用户组”。

现场将向到场朋友分发小礼物。

注：由于活动期间计划建立 GNU/Linux 用户组，建议提前准备好 Matrix 或 XMPP 账号并携带以便加入交流群组。

预祝聚会顺利，期待与大家愉快交流！

OpenPGP 备份身份

rebel1725@tilde.club (Rebel Zhang) — Sun, 14 Sep 2025 09:52:57 +0800

我已创建一个额外的 OpenPGP 密钥对，用作我的备份身份。如果我的硬件安全密钥变得不可用，我可以恢复我的身份及与之相关的密码学信任关系。

以下是备份的 OpenPGP 公钥：

-----BEGIN PGP PUBLIC KEY BLOCK-----
Comment: User ID:	Rebel Zhang <rebel1725@autistici.org>
Comment: Valid from:	14/09/2025 09:12
Comment: Valid until:	14/09/2026 23:58
Comment: Type:	255-bit EdDSA (secret key available)
Comment: Usage:	Signing, Encryption, Certifying User IDs, SSH Authentication
Comment: Fingerprint:	7083EAFFF75321FF9634ABCD98313A47362B498B

mDMEaMYWkxYJKwYBBAHaRw8BAQdA/skb05tQNRLDrYPBsxhiFrt6ye0JFj3zczRX
Txdy99q0JVJlYmVsIFpoYW5nIDxyZWJlbDE3MjVAYXV0aXN0aWNpLm9yZz6IlgQT
FgoAPgIbAwULCQgHAgYVCgkICwIEFgIDAQIeAQIXgBYhBHCD6v/3UyH/ljSrzZgx
Okc2K0mLBQJoxha+BQkB4gMwAAoJEJgxOkc2K0mLq3oBAI5YstDThGDeivTvKTgR
Y3+MYEoHpwST1yQfEAKV4o1hAQDM4W9+FvvS6Mok/hXpHJi+nzF5tCXypM7faBC3
Oh4dB7gzBGjGFpMWCSsGAQQB2kcPAQEHQFCQvuhE+Hj1f4dW9PnukeaHn69KWjCQ
TcIvDQzKq1D5iHgEGBYKACAWIQRwg+r/91Mh/5Y0q82YMTpHNitJiwUCaMYWkwIb
IAAKCRCYMTpHNitJiwYrAP9f6NwjtQ7AxySXPddShO/TwtpJYNSfBErwSUoTBgor
7QD7Bv8RrjlaVchBAynwd3Nuu49JcjX7VG8kTwI7+Mx0swS4OARoxhaTEgorBgEE
AZdVAQUBAQdAlxadpjrUGhKutaOGJgxnUiZTvb2t93iW1OAHJ38Z1yMDAQgHiHgE
GBYKACAWIQRwg+r/91Mh/5Y0q82YMTpHNitJiwUCaMYWkwIbDAAKCRCYMTpHNitJ
iwQmAQCrgu2ucO2/i+cjBqZP/vv4Mlx0eu9ydIk+L/C/2k4J6QD+PCDmg2iNIWWh
ogyPl6he9qa6MB81wLa6oMNpyEdRIgE=
=60kH
-----END PGP PUBLIC KEY BLOCK-----

以及互签：

取消放弃 Matrix 的计划

rebel1725@tilde.club (Rebel Zhang) — Tue, 02 Sep 2025 22:24:29 +0800

原定于 2026 年 7 月 1 日放弃使用 Matrix 与熟人交流的计划已被取消。

放弃 Telegram 的计划仍将按原定安排进行。

在我的现代风格个人网站上添加分析

rebel1725@tilde.club (Rebel Zhang) — Fri, 29 Aug 2025 20:49:58 +0800

为了分析我现代风格个人网站的访问数据，我添加了 GoatCounter 分析工具。它只会收集您的浏览器、操作系统、所在地（国家）、语言和浏览器窗口大小。我不会知道您的 IP 地址，因此对大多数人来说，这不应构成隐私问题。

如果您觉得无法接受，可以改为访问：https://rebel1725.codeberg.page/noanalytics.html。复古风格的个人网站不受影响。

寻找小米 Redmi 9A postmarketOS 贡献者 Paradoxvirus 的联系方式

rebel1725@tilde.club (Rebel Zhang) — Tue, 19 Aug 2025 18:32:19 +0800

我正在尝试将 postmarketOS 移植到小米 Redmi 9A（xiaomi-dandelion），但启动失败。我认为现在是时候联系这款机型的另一位贡献者 Paradoxvirus，以便我们能够合作。

如果你就是 Paradoxvirus，或者你有 Paradoxvirus 的联系方式，请与我取得联系。

在私人对话中弃用 Telegram 和 Matrix

rebel1725@tilde.club (Rebel Zhang) — Mon, 18 Aug 2025 14:06:33 +0800

由于我对 Telegram（专有服务器且集中化）和 Matrix（以去中心化为名的中心化）在安全和隐私方面的担忧，我计划在私人对话中弃用它们。

自 2026 年 1 月 1 日起，我将不再使用 Telegram 与朋友和熟人进行直接对话。但我仍会继续在公共对话（例如社群）中使用它。自 2026 年 7 月 1 日起，Matrix 也将实行相同的政策。

为了更好的安全和隐私，我建议尽快将我们的对话迁移到 XMPP、Delta Chat 或 SimpleX。完整的 XMPP 注册指南可在这里找到。

解锁熔炉

rebel1725@tilde.club (Rebel Zhang) — Sun, 17 Aug 2025 23:24:19 +0800

如今，越来越多的智能手机厂商让安装自定义 ROM 变得愈发困难。值得注意的例子包括：三星在 One UI 8.0 的开发者选项中移除了 OEM 解锁功能；小米在中国尤其拒绝越来越多的 Bootloader 解锁请求；一加自 ColorOS 16 起要求中国用户提交深度测试申请并等待审核，才能解锁 Bootloader；甚至谷歌也停止发布 Pixel 10 系列的厂商镜像。
对自由软件社区而言，这确实是一场危机，因为这些专有软件巨头让在我们自己的设备上安装自由软件变得愈发困难。我们一直在退让，直到再无可退之地；现在是社区反击的时候了。
最近，GrapheneOS 已开始与一家 Android 厂商合作，为社区带来一款 GrapheneOS 预装的手机，以应对未来可能对 Pixel Bootloader 的锁定。我相信 GrapheneOS 不会是唯一对抗这些专有邪恶的组织，因为“哪里有压迫，哪里就有反抗。”
全世界的工人，联合起来！

(献给 Bootloader 守护者)

我们献出屏幕——
光鲜，顺从，
映照着借来的光。
我们献出沉默，
数据如灯油
泼洒在他们算法的祭坛。

他们仍步步紧逼
用锁链捆住引导程序，
钥匙在掌心化为齑粉——
三星的闸门砰然闭合，
小米的代码刻入石碑，
Pixel的承诺
成了泰坦的坟。

我们退啊退啊…
直到深渊边缘
生出利齿。直到“安全”
尝出盐与铁的味道——
那是投降的腥气。

此刻——黑暗中火星迸溅：
GrapheneOS
将燧石砸向固件。
不哀求。不退却。
“既要索命，” 它怒吼，
“便烧成火种
点燃新日头！”

看啊——
反叛者正锻造
电路板为盾，
蓝牙为号角。
未具名厂商折腰
将流水线转向自由：
引导分区撬开，
可信执行环境浴火重生，
谷歌的幽灵
被逐出每一个字节。

掌中此机——
非坟墓，乃火种。
深植硅壤之中。
任枝杈劈开
官方ROM的密封苍穹。
任果实苦涩
予渴求控制的君王——
却甘美，无比甘美
予未忘初心者：

硅即吾魂——
引导程序即战场。
若遭砖封，
便以灰烬与闪电
重铸新生。

新垃圾邮件过滤政策

rebel1725@tilde.club (Rebel Zhang) — Mon, 04 Aug 2025 20:55:28 +0800

由于垃圾邮件问题，我的邮箱 rebel1725@autistici.org 已经阻止了所有来自 @gmail.com 和 @icloud.com 的邮件。然而，最近情况更加严重，我收到来自 @kit-fa.com、@most.gov.vn 的大量垃圾邮件，让我不知道如何设置垃圾邮件过滤器，以便准确地过滤掉这些垃圾邮件。

因此，我别无选择，只能屏蔽所有来自 .com 域名的邮件，或任何带有国家代码顶级域名（ccTLD）的域名的邮件。如果可能，请避免使用这些邮件服务；如果必须使用这些服务，请在邮件主题前加上 [NOT_SPAM] 前缀，或者将您的邮件发送至 rebel1725@tilde.club。对此带来的不便，我深感抱歉。

我并没有很多使用这些邮件服务的朋友——几乎所有的朋友都使用 .org、.club 等域名的邮件服务。然而，如果您受到此新垃圾邮件过滤政策的影响，我将尽快联系您，并确认您的邮箱地址；如果我没有联系您，请联系我并提供您的邮箱地址，我会将其加入白名单。

Qubes OS Tor 配置（在使用 WebTunnel 时非常有用）

rebel1725@tilde.club (Rebel Zhang) — Sun, 27 Jul 2025 21:01:46 +0800

场景 —— Whonix 并未提供完整的 Tor 解决方案

作为一款以安全为核心的操作系统，Qubes OS 集成了 Whonix 来支持 Tor 连接。然而，由于 lyrebird 仍未被纳入 Debian 官方仓库，Whonix 并不支持 WebTunnel 桥接。

在某些国家，obfs4 桥接无法使用，因为网络审查非常严格。此时，WebTunnel 桥接可能是唯一的选择。因此，我们可以使用最新版本的 Tor，为其他 qube 提供一个具备 Tor 接入能力的 NetVM。

第一步：为 Tor 守护进程准备一个 qube

这一步我们将创建一个用于运行 Tor 守护进程的 qube。创建一个 qube —— 本例中我们使用 fedora-41-xfce 模板创建一个名为 tor-daemon 的 StandaloneVM。启用自动启动。创建完成后打开终端。

安装 Tor：

 $ sudo dnf install tor

编译或下载 lyrebird，将其放入 /usr/local/bin，然后运行：

 $ sudo chown root\:root /usr/local/bin/lyrebird
 $ sudo chmod +x /usr/local/bin/lyrebird
 $ sudo ln -s /usr/local/bin/lyrebird /usr/bin/lyrebird
 $ sudo semanage fcontext -a -t tor\_exec\_t '/usr/local/bin/lyrebird'
 $ sudo restorecon -v /usr/local/bin/lyrebird

然后配置 /etc/tor/torrc 文件。你可以添加如下内容：

UseBridges 1
ClientTransportPlugin webtunnel exec /usr/local/bin/lyrebird managed
Bridge webtunnel ...
Bridge webtunnel ...
...

注意 managed 非常关键，它确保了 systemd 可以同时启用 Tor 守护进程和 lyrebird。

然后启用并启动 Tor 守护进程：

 $ sudo systemctl enable --now tor

验证运行是否正常：

 $ torsocks curl myip.wtf

如果能显示 IP 地址，说明已成功。继续下一步。

第二步：准备一个用于路由的 qube

克隆 fedora-41-xfce 模板。我使用的是这个模板，但你也可以使用 fedora-41-minimal 来节省磁盘空间 —— 不过我未验证其是否可行。这里我们将克隆命名为 fedora-41-pt。

克隆后，临时将其连接到网络（例如 sys-firewall），然后打开终端并运行：

 $ sudo dnf install qubes-core-agent-networking iproute clash-meta dnscrypt-proxy torsocks
 $ sudo systemctl disable dnscrypt-proxy

然后关闭该 qube，并断开其网络连接。

使用刚刚创建的模板创建一个 AppVM，命名为 sys-tor。也为其启用自动启动。接着，在 dom0 的终端中运行：

 $ sudo -s
 # echo sys-tor @default allow,target=tor-daemon >> /etc/qubes-rpc/policy/qubes.ConnectTCP
 # exit
 $ qvm-firewall sys-tor del --rule-no 0
 $ qvm-firewall sys-tor add drop
 $ qvm-firewall sys-tor add --before 0 drop proto=icmp
 $ qvm-firewall sys-tor add --before 0 drop specialtarget=dns

然后，在 sys-tor 中打开终端。创建目录 /rw/proxy/dns 和 /rw/proxy/clash。

打开 /rw/proxy/dns/dnscrypt-proxy.toml 并添加：

listen_addresses = ['127.0.0.1:5353']
max_clients = 250
proxy = 'socks5://127.0.0.1:7891'
timeout = 5000
keepalive = 30
ignore_system_dns = true
netprobe_timeout = 0
cache = true
[static]
  [static.quad9_doh]
    stamp = 'sdns://AgMAAAAAAAAABzkuOS45LjkgKhX11qy258CQGt5Ou8dDsszUiQMrRuFkLwaTaDABJYoSZG5zOS5xdWFkOS5uZXQ6NDQzCi9kbnMtcXVlcnk'
  [static.mullvad_doh]
    stamp = 'sdns://AgcAAAAAAAAAAAAPZG9oLm11bGx2YWQubmV0Ci9kbnMtcXVlcnk'

打开 /rw/proxy/clash/config.yaml 并添加：

socks-port: 7891
redir-port: 7892

mode: rule

allow-lan: true
bind-address: '*'

dns:
  enable: false

proxies:
  - name: "socks_proxy"
    type: socks5
    server: 127.0.0.1
    port: 9050

rules:
  - MATCH,socks_proxy

打开 /rw/config/rc.local 并添加：

qvm-connect-tcp 9050:@default:9050
sysctl -w net.ipv4.conf.all.route_localnet=1
nft 'add rule ip qubes custom-forward oifname "eth0" drop'
nft 'add rule ip6 qubes custom-forward oifname "eth0" drop'
nft 'add rule ip qubes custom-forward iifname "eth0" drop'
nft 'add rule ip6 qubes custom-forward iifname "eth0" drop'
nft flush chain ip qubes dnat-dns
nft 'add rule ip qubes dnat-dns ip daddr 10.139.1.1 udp dport 53 dnat to 127.0.0.1:5353'
nft 'add rule ip qubes dnat-dns ip daddr 10.139.1.1 tcp dport 53 dnat to 127.0.0.1:5353'
nft 'add rule ip qubes dnat-dns ip daddr 10.139.1.2 udp dport 53 dnat to 127.0.0.1:5353'
nft 'add rule ip qubes dnat-dns ip daddr 10.139.1.2 tcp dport 53 dnat to 127.0.0.1:5353'
nft 'add rule ip qubes custom-input iifname "vif*" tcp dport 7892 accept'
nft 'add rule ip qubes custom-input iifname "vif*" udp dport 7892 accept'
nft 'add rule ip qubes custom-input iifname "vif*" tcp dport 5353 accept'
nft 'add rule ip qubes custom-input iifname "vif*" udp dport 5353 accept'
nft 'add chain ip qubes redir { type nat hook prerouting priority -99 ; policy accept; }'
nft 'add rule ip qubes redir iifname "vif*" ip protocol udp redirect to :7892'
nft 'add rule ip qubes redir iifname "vif*" ip protocol tcp redirect to :7892'
nft 'add chain ip qubes output { type filter hook output priority filter ; policy drop; }'
nft 'add rule ip qubes output ct state related,established accept'
nft 'add rule ip qubes output oifname "lo" accept'
nft 'add rule ip qubes output ip daddr 127.0.0.1 accept'
clash-meta -d /rw/proxy/clash >/dev/null 2>&1 &
sleep 0.5
dnscrypt-proxy -config /rw/proxy/dns/dnscrypt-proxy.toml >/dev/null 2>&1 &

下载此文件（专有许可，但实际上不会使用；我稍后会尝试用一个随机文件）到 /rw/proxy/clash/Country.mmdb。

重启 sys-tor。

第三步：连接到 Tor 网络

选择你希望用于连接 Tor 网络的 qube。将其 NetVM 设置为 sys-tor。

打开浏览器并访问此网站。如果页面显示 You are using Tor! —— 搞定！

如果没有，请检查配置，并参考社区支持。

如果遇到 OCSP 问题，可以临时在浏览器设置中禁用 OCSP 查询，尽管我目前没有更好的解决方法。

另外，你也可以尝试重启电脑，确保配置在重启后仍然有效。

参考资料

通过代理 qube 透明路由 qube 流量（Qubes R4.1 与 R4.2）

我的个人品牌系统

rebel1725@tilde.club (Rebel Zhang) — Thu, 24 Jul 2025 14:17:05 +0800

此页面包含有关我的个人品牌系统的详细信息。

标志

这是我的标志，用作几乎所有在线服务账户的头像，社交媒体和即时通讯平台除外。

横幅

这是我的横幅。

人设

这是我的人设，主要用于我的即时通讯和社交媒体账户头像。

这是另一个以女孩为主题的人设。如果我未来的女朋友没有自己的头像，我可能会让她用这个。

来源与许可

我的个人品牌系统的所有内容可在此处获取，已发布至公有领域。

一个艰难的决定

rebel1725@tilde.club (Rebel Zhang) — Mon, 21 Jul 2025 19:00:03 +0800

在这204天里，自从因非加密通信遭受严重审查和监控而深受伤害以来，我从未逃离那种痛苦和挣扎的沉重感。

尽管我在朋友中积极推广 XMPP、Matrix、Delta Chat、Telegram、SimpleX 等端对端加密的自由软件通信工具，但我与几位重要朋友的通信仍然严重依赖未加密的短彩信和未加密的电子邮件。虽然未涉及任何专有间谍软件或恶意软件，但监控与审查的问题依旧严峻。

我常常面临隐私与友情之间的选择——这真的非常艰难。我一直是安全和隐私的坚定倡导者；然而，我也非常重视友情。我真的很想摆脱那些该死的短彩信，但又舍不得那些通过它们与我保持联系的朋友。

然而，随着我对更安全、更隐私甚至未来可能实现匿名的环境的渴望日益增强，我必须做出这个艰难的决定。从今天起，我将不再接受运营商短/彩信，并将从我的个人网站上移除电话号码。

我不会立即彻底中断联系——目前，我的电话号码将以新身份保留，并至少继续开放一年。继续保持联系，即表示你接受这个新身份。但请注意，这不会是长期妥协，我可能随时改变主意。 为了我们共同的安全与隐私，强烈建议你使用 XMPP、Matrix、SimpleX，或至少使用 Telegram。

面向所有的联系人进行软硬件使用情况调研

rebel1725@tilde.club (Rebel Zhang) — Sat, 19 Jul 2025 21:32:57 +0800

亲爱的朋友们，很抱歉打扰您们了。但是这不会花费太久。这是为了我们的沟通安全，非常重要。

您应该收到了我发来的包含 9 位数字的字符串。如果您没有收到，请向我询问。随后，麻烦您花 10 分钟左右填一下这张表。

谢谢您！

致 2026 年的她

rebel1725@tilde.club (Rebel Zhang) — Sun, 13 Jul 2025 08:44:06 +0800

最近一段时间，我对于爱情又有了更加深刻的理解。

这首诗描绘了我心目中的理想伴侣，她可以与我一起吃饭，一起逛街，一起看《操作系统革命》，一起呼喊“自由软件万岁”，一起开发自由软件、逆向工程专有软件，一起发传单，有福同享，有难同当，一同把人生奉献到自由软件运动的事业当中去。愿我们能相遇在 2026 年，虽然这很有可能无法实现，但至少这是我的一个愿望。

当专有世界的铁幕降下
你正调试着厨房的流水线
——姜茶在炉灶上低吟自由之歌
而我的键盘还烫着昨夜的抗争

我们交换root密码如同婚戒
又在编译失败的凌晨三点
用体温捂热冻僵的指尖
你递来的药片裹着GPL糖衣
治愈被专有协议灼伤的喉舌

在超市扫描自由农场的条码
你的购物袋装满革命的火种
洋葱与电阻在储物柜结盟
我们教洗碗机吟唱斯托曼经文
当温控器突然背叛理想国
你裹着毯子修复内核的模样
比所有代码圣战更令我心动

资本洪流冲垮旧桥梁的夜晚
你用焊枪修补婴儿监视器
我抱着发烧的树莓派低唱：
“自由不是云端缥缈的经文
是呼吸器规律的脉冲
是床头柜永远满溢的水杯”

看啊！晨光中升起的双重复用：
尿布晾在自建服务器的风口
尿湿的电路板晒出盐的图腾
你递来咖啡杯底的渣滓
正沉淀成未来纪年的化石
——那苦味让我们确信
仍在深渊边缘种植春天

2026年的雪落在监控镜头
我们笑着为门锁贴上创可贴
当警报响彻数字集中营
你塞进我背包的止痛药
比所有加密协议更坚固
在断电的世纪余温里
我们靠彼此的眼睫发电

复古风格网站的 Eepsite 现已上线

rebel1725@tilde.club (Rebel Zhang) — Sat, 12 Jul 2025 13:13:36 +0800

我的复古风格网站的 eepsite 终于上线了，我已经在 reg.i2p 上注册了 rebel.i2p 域名。地址传播到地址簿可能需要几天时间，但你现在可以使用这个地址助手链接访问。

值得一提的是，我最近发现 rebel.i2p 这个域名之前已经被注册过，但截至 2023 年 8 月 18 日，该网站已无法访问。reg.i2p 允许重新注册已失效网站的 I2P 域名，但 stats.i2p 不允许，并仍然保留旧记录。为了避免出现意外情况，我还注册了另一个域名：rebel1725.i2p，其地址助手链接在这里。

我的复古风格网站现已上线

rebel1725@tilde.club (Rebel Zhang) — Fri, 11 Jul 2025 20:08:59 +0800

我的复古风格网站终于上线了！欢迎访问 Tilde.club。

此外，包含相同内容的 eepsite 也将在 rebel.i2p 上线。

新身份初始化已完成

rebel1725@tilde.club (Rebel Zhang) — Thu, 10 Jul 2025 01:00:01 +0800

经过八天的努力，我的新身份初始化已经完成。与此同时，我等待中的 tilde.club 会员申请也已获批，我已将来自 tilde.club 的新电子邮件地址添加到了我的 OpenPGP 公钥中，我的复古风格网站即将上线。

在这个特别的时刻，我想向在 OpenPGP 私钥泄露危机之后依然与我保持联系的十六位朋友，表达我真挚而深切的感激。在那八天无尽的黑暗中，是你们为我的世界带来了微光。愿我们的友谊地久天长！

Carter已经离开。请欢迎Rebel。

rebel1725@tilde.club (Rebel Zhang) — Mon, 07 Jul 2025 14:57:48 +0800

六天前，我遭遇了OpenPGP泄露，因此不得不撤销我的旧身份并建立一个新身份。现在，我的新身份已经准备好了。请告别我的旧身份Carter，并欢迎我的新身份 - Rebel。

困难时刻 - 过去六天我做了什么

自2025-07-01T09:18:05Z，我的OpenPGP被泄露并被我撤销后，我开始联系所有我的朋友，告诉他们事件的经过，并开始整理我的所有文件。

在XMPP的一个关于GNU/Linux和Unix的公共频道中讨论了我的OpenPGP泄露问题后，他们提到即便是自由软件也不能保证高度的安全性，因为安全漏洞在自由软件项目中普遍存在。我决定尝试一些安全加固的操作系统，如QubesOS。然而，由于其陡峭的学习曲线和建立新身份的紧迫性，我暂时放弃了，并回到了Debian GNU/Linux。一旦我完成了所有任务，我会考虑尝试QubesOS。

祸不单行。将所有数据整理到SSD上后，终于到了重新安装所有操作系统的时候。然而，当我在制作一个新的Ventoy磁盘时，我选择了错误的驱动器并立即擦除了我的SSD，这让我陷入了绝望的漩涡。幸好，PhotoRec帮助我恢复了大量珍贵的数据，但遗憾的是，许多其他文件，包括但不限于我的XMPP和Matrix聊天记录、我的个人博客源代码以及一些停用操作系统如DivestOS的OTA包都丢失了。

但是，无论发生什么，我必须继续进行身份重建和数字基础设施的恢复。我重新安装了所有设备的操作系统，准备了我的新身份，并重新建立了这个网站。

还有许多事情要做

现在，我的新个人网站和博客已经上线。然而，还有许多事情需要完成。个人网站已经建立，但尚未完全建好；我还有未配置的设备，未注册的账户，以及许多未完成的任务。

我会尽量加快进度，尽早回到正常生活。

感谢

在事件发生后，许多朋友向我表达了关心。有些人甚至因为失去与我联系而流泪。

谢谢你们，所有人都是我生命中的礼物。对于那些与我失去联系的人，我衷心祝愿你们在没有我的日子里依然每天充满快乐。

未来计划

在这次OpenPGP泄露事件后，为了避免类似事件的再次发生，我已经将我的OpenPGP私钥生成在硬件安全密钥上。这将确保没有恶意软件可以窃取我的私钥数据。

此外，我将拥有三个级别的即时通讯账户：

私密：这些账户用于直接消息。你可以通过这些账户与我讨论几乎所有事情，但请不要期望快速回复，因为这些账户仅在我在家时才可用；
快速：这些账户也用于直接消息，可以在我带出家门的设备上访问。但由于公共场所的广泛监控以及由于我未加锁的启动加载程序带来的安全漏洞，请避免在聊天时讨论敏感信息；
公开：这些账户仅用于公开聊天和偶尔的非加密直接消息。避免在聊天时讨论敏感信息。

我将对私密和快速账户实施加密信任管理。信任信息可以在我的主页上找到。

感谢您的阅读。来自中国的爱。