<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>AI辅助 on Tech Philosopher</title><link>https://blog.bktus.com/tags/ai%E8%BE%85%E5%8A%A9/</link><description>Recent content in AI辅助 on Tech Philosopher</description><generator>Hugo</generator><language>zh-CN</language><lastBuildDate>Thu, 19 Nov 2026 21:06:01 +0100</lastBuildDate><atom:link href="https://blog.bktus.com/tags/ai%E8%BE%85%E5%8A%A9/index.xml" rel="self" type="application/rss+xml"/><item><title>GpgFrontend 新的版本模型与发布机制</title><link>https://blog.bktus.com/archives/2e68mf/</link><pubDate>Thu, 19 Nov 2026 21:06:01 +0100</pubDate><guid>https://blog.bktus.com/archives/2e68mf/</guid><description>&lt;p>更新一直是 GpgFrontend 的一大痛点。从最初的版本开始，GpgFrontend 就一直依赖 GitHub Release 来发版和检查更新，这样用了很多年。从 2.2.5 开始，包括现在的主线，版本号的规则、发布的流程，还有客户端检查更新的方式，都换成了一套新的模型和机制。具体怎么用、怎么验证，用户手册里已经写了，但是为什么要这样做，我当时是怎么想的，这些在文档里体现不出来。&lt;/p></description><content:encoded><![CDATA[<p>更新一直是 GpgFrontend 的一大痛点。从最初的版本开始，GpgFrontend 就一直依赖 GitHub Release 来发版和检查更新，这样用了很多年。从 2.2.5 开始，包括现在的主线，版本号的规则、发布的流程，还有客户端检查更新的方式，都换成了一套新的模型和机制。具体怎么用、怎么验证，用户手册里已经写了，但是为什么要这样做，我当时是怎么想的，这些在文档里体现不出来。</p>
<p>对于 GpgFrontend 这样的安全软件来说，透明是一个基本的要求。更新这件事情又直接关系到用户电脑上装的到底是什么东西，客户端在背后访问了哪里、发送了什么，用户有理由怀疑。所以我觉得有必要把它说清楚，让用户知道更新相关的东西究竟是什么样子的。GpgFrontend 一路过来的经历，可以看我<a href="https://blog.bktus.com/archives/5l9c2j/">之前的文章</a>。</p>
<h2 id="用了很多年的-github-release">用了很多年的 GitHub Release</h2>
<p>一开始，GitHub Release 其实挺好用的，至少到前两年为止都是这样。一个是它可以免费分发，另外一个是它的模型足够简单，release 和 Git 的 tag 绑定在一起。发版的时候，只要打一个 tag，写一份 Release Note，然后把 GitHub Actions 构建出来的安装包一股脑传上去，就 OK 了。</p>
<p>后来，项目的迭代速度加快了，特别是引入了 AI 相关的代码辅助之后，包括现在的 agent，功能也增加了很多。这些功能平时不一定感受得到，但是真正去用的话，还是会发现一些问题。按照原来 tick-tock 的节奏，是两个月发一版。很多时候，发版前没发现的问题，会在发版后的一两天、两三天之内被我自己或者其他人发现，这个时候我就很难马上再发一版，因为节奏就是两个月一个版本，中途要发版就很麻烦。</p>
<p>但是反过来，天天发版也不好。大部分用户在意的是稳定，并不想尝鲜，他们可能两个月才检查一次更新，或者更久。反正新功能大部分用户一般都是用不到的，他们用的是加密、解密、生成密钥这些。比如说邮件这块，以前基本上只能操作 EML 文件，我自己都承认它比较难用，现在邮件模块做了比较大的改动，基本上能覆盖日常使用邮件的场景了，但用它的人还是少数。</p>
<p>所以，对于大部分用户来说，等两个月应该没有什么感觉，因为我发版前会检查，基本的功能不会出问题。但是真的遇到问题的用户，要等两个月才能收到修复后的版本，那就比较难受了。我自己就能感受到这一点，不过我发现问题可以直接去修，然后自己编译自己用，反正我没有什么影响。但是我想象一下，如果没有条件自己编译，或者是一个非技术用户，那就要等两个月。</p>
<p>所以后面引入了 Nightly Build，它跟随我的开发主线，原来是跟随 develop 分支，现在是跟随 main 分支。我只要 commit，然后 push 到 GitHub 上，就会自动触发流水线进行构建。Nightly 和稳定版肯定是有区别的，稳定版再怎么说，都是经过验证的一些功能的集合，而主线上会引入很多新的功能。这些新功能大部分时候不会和稳定的功能冲突，但有些时候我会做一些架构上的调整或者优化，这个时候还没法验证它不会影响稳定性。所以 Nightly 用的是和稳定版不同的 profile，它作为一个单独的应用 GpgFrontend Testing 运行，有自己的密钥和设置。</p>
<p>发布方式上，Nightly 只有一个 <code>nightly</code> tag。流水线运行的时候，会拉取分支上最新的 commit 进行构建，然后强制覆盖现有的 <code>nightly</code> tag，再用相应的 action 插件创建 release，自动填好 Nightly Build 的 Release Note 模板。稳定版还是原来 <code>vX.Y.Z</code> 那样的 tag。这样 Nightly 和稳定版在 GitHub Release 上共存，至少用了一两年，感觉还行。不过 Nightly 没有 1、2、3 这样的编号，用户只能看到最新的那一个。</p>
<h2 id="转折点22-与多条版本线">转折点：2.2 与多条版本线</h2>
<p>真正的转折点是 2.2 版本。2.2 引入了第二个引擎，GnuPG 引擎和 RPGP 引擎可以同时使用，这是一次比较大的架构调整。当时需要时间来证明，引入 RPGP 带来的这些调整，不会影响现有的以 GnuPG 为主的用户。所以当时保留了 2.1 这条线，它是原来单引擎的版本线，照常更新，2.2 这条线也继续往前走。</p>
<p>这个时候，2.1 的用户很可能想留在 2.1 上。那么对于他们，只能优先推 2.1 的更新，等 2.2 稳定以后，再推荐他们升级到 2.2。如果用 GitHub Release 来做这件事情，就只能把客户端的逻辑加厚：客户端去访问 GitHub Release 的 API，判断 2.2 有哪些版本，2.1 有哪些版本，拿到每个版本的元数据，然后在本地计算 2.1 是不是有新版本了，2.2 是已经稳定了还是处于 pre-release 状态，有没有撤回之类的，最后再通知用户。这样实现起来虽然可行，但我一直感觉比较别扭。</p>
<p>GitHub 的 release 模型虽然能够表达两条版本线，但是它，怎么说呢，少了一些灵活性。比如说，发布 release 的时候可以把某个 release 标记成 latest，但是这个 latest 是所有版本里的 latest。对于某条旧的版本线，比如说为了兼容系统版本比较低的用户而保留的那条线，它的最新版并不是整个项目的最新版。</p>
<p>另外一个是 EOL（End of Life）的问题。比如说我打算让 2.1 在某一年的 12 月 31 号终止，用 GitHub Release 的话，总不能把 2.1 全部下架吧，这些东西都是要归档、要存底的。那就只能在客户端里写死：12 月 31 号以后 2.1 就是 EOL，推荐升级到 2.2。可是客户端是装在用户电脑上的软件，一旦发布出去，这个值就很难改了。如果我想把支持期往后延，或者提前，除非在某个地方远程读取这个值，否则就没有办法。</p>
<p>还有就是 Rate Limit。GitHub 的 API 是有访问频率限制的。我以前在公司里，用自己的电脑下载了 GpgFrontend，想检查一下更新，结果整个公司的出口 IP 已经达到了上限，根本没法用。挂 VPN 很多时候也一样，除非登录，可是客户端又登录不了，这就很尴尬。再就是它和平台绑得太紧了，只能用 GitHub 分发。如果我想在网站上自动判断用户的平台，给一个下载链接，那也只能链到 GitHub 上，下载也不是很稳定，挂 VPN 的时候速度会比较慢，用起来不是很爽。（至于很多人因为 GitHub 被微软收购了，不想访问 GitHub 相关的东西，这个是题外话，不是主要原因。）</p>
<p>当然，这些在 GitHub Release 上也不是完全做不到。比如说在 Release Note 里写一些约定好的东西，客户端去读取，再根据这个来判断。但是一个是不规范，另外一个是脆弱。就像一把菜刀，什么地方都能用，但是遇到一些特殊情况，用起来就是磕磕绊绊的。</p>
<p>也正是因为 GitHub 这一套要加的逻辑太多，而且很容易出错，我干脆没加，把更新检查的插件做得非常简单：只访问 GitHub，只读一些简单的元数据，然后做判断。结果就是这个插件并不好用，也几乎没有做验证。客户端怎么知道一个新推出的版本是经过签名的？从 GitHub 上很难方便地拿到这些签名，以及签名背后那个“根”之类的元数据。其实我自己平时都不太用这个更新插件。</p>
<h2 id="新的版本号规则">新的版本号规则</h2>
<p>在说新的发布机制之前，先说一下版本号的变化。原来的规则下，最后一位变了，并不代表这只是一个补丁，它代表在某个方向上又往前走了一步。比如说 2.1 这个方向，就是在单引擎上不断完善各种功能；2.2 是多引擎，2.2.1、2.2.2 只是在多引擎这个方向上继续探索，并不代表这次更新很小。确实有人提过这个问题，当时我就是这么解释的。从 1.0 一直到 2.2.4，我的想法都是这样。</p>
<p>从 2.2.5 开始，为了适应新的发布模型，或者说让它更合理一些，最后一位现在真的就只是补丁：</p>
<ul>
<li>第一位是“代”（Generation），比如从 1.0 到 2.0 那种变化。只有非常重大的架构调整，或者整个产品的思路变了，才会动它，和引入了多少行代码没有关系。</li>
<li>第二位是功能版本，也就是原来的“方向”。2.2 到 2.3，2.3 到 2.4，是真的有大的改动，大约两个月一次。</li>
<li>第三位是修复版本。2.3.1 到 2.3.2，2.3.2 到 2.3.3，回归它本来的意思，以安全更新和修复为主，可能会带一些特性，但尽可能少带，除非真的有必要。</li>
</ul>
<p>这样的好处在于，稳定的用户不需要新特性，也能享受到修复。比如说一个用户不想用双引擎，但想要 GnuPG 引擎相关的安全修复，或者他想停留在用得比较顺的 2.2 上，不想到 2.3 去。对我来说，也可以比较容易地控制各条版本线的节奏，把主线上的修复 cherry-pick 到各条线上，再通过现在的更新机制推送给对应的用户。2.2 到 2.3 只是推荐而已，你依然可以留在 2.2 这条线上接收补丁。</p>
<p>不过我一个人很难维护很多条版本线。一般是这样的情况：我想从 2.2 往 2.3 推进，但 2.3 引入了很多新东西，没那么快稳定下来，那 2.2 肯定还要继续存在一段时间，这个时候就是两条线。再加上 2.1 这条比较重要的单引擎线，就是三条，最多就维护三条。目前的状态是：2.3 是主线，2.2 是稳定版，2.1 是 legacy，只接收安全修复，到 2027 年 12 月 31 日为止，它也是最后一个能用 Qt 5 构建的系列。在新的机制下，我可以偶尔更新一下 2.1，按原来的节奏更新 2.2，然后继续把 2.3 往前推。这些状态都写在仓库的 <code>release/policy.toml</code> 里。</p>
<p>另外，Nightly 的版本号也变了。以前我把版本号，比如 2.3.0，写在 CMake 工程里，所有的 Nightly Build 都是 2.3.0，不管是在哪个 commit 上构建的。用户虽然可以在构建信息里看到 commit，但是引用起来并不方便。现在 Nightly 的版本号由 git 推出来，形如 <code>2.3.0-alpha.138+g&lt;commit&gt;</code>，<code>alpha</code> 后面的数字是从最近一个基准 tag 到现在的提交数量。这样别人好引用，我也好找，不用再去翻那么长的 commit message、再去仓库里对应，看到 alpha.250，大概就知道是哪一天的版本。用户也可以保留最近三四个 Nightly，新的不好用，就暂时退回原来的版本，等新的开发阶段过了再更新。</p>
<p>除了稳定版和 Nightly，还有 beta 和 RC（Release Candidate）。比如说我准备发 2.4 了，感觉主线上的功能差不多了，但还不是很稳定，想让愿意试用的用户先试一试，这个时候就会有 <code>2.4.0-rc.1</code> 这样的 RC 版本。beta 是某条线下一个修复版本的测试构建，版本号类似 <code>2.3.2-alpha.3</code>。beta 和 RC 只推给在设置里主动勾选了“Also offer beta versions”的用户，这个选项默认是关的。</p>
<h2 id="发布机制三个存储桶和一台更新服务器">发布机制：三个存储桶和一台更新服务器</h2>
<p>说完了版本模型的背景，再说发布机制。我现在不太想用 GitHub Release 作为主要的发布渠道了，最大的痛点还是前面说的，一个是速度比较慢，另外一个是有 Rate Limit 限制。</p>
<p>我其实一直对对象存储比较感兴趣，感觉应该用 AWS S3 这样的对象存储来托管。用一个普通的网页其实也可以，但是相比之下，客户端只需要获取一个元数据文件，比如一个 JSON，并不需要网页附带的 JS、CSS 这些东西。而且网页服务器有可能允许别人扫描目录，这就比较麻烦，我并不希望别人能一下子拿到全量的东西。我更希望元数据是隔离开的，客户端先拿到根上的元数据，需要别的东西时，由这个元数据指示下一个索引在哪里，再去访问。很多技术上的东西，用不同的方法都能做，但有些时候会有一种直觉，哪一种更好一些，更让我舒服一些。</p>
<p>本来想用 S3，但是它的出流量是单独计费的，我很难把控。这个软件会不会遇到 DDoS 攻击，一下子被拉走几百 TB 的流量？靠捐赠的那点钱，天天几百 TB，那是负担不起的。后来我发现 Cloudflare 的 R2 不对分发的流量收费，而且 Cloudflare 的 CDN 我一直在用，虽然它前段时间出过一些事故，但是对于软件分发这种不需要高可用的服务来说，还是 OK 的。所以就选了 R2。</p>
<p>然后就是在存储桶里存什么，以及谁来往里面放东西。我给自己定的宗旨是：新的机制一定要把我个人的精力解放出来，让发版变得更快，特别是稳定版。原来发一个稳定版，我要把安装包一个个下载下来，在我的 Windows 电脑上做 Authenticode 证书签名，然后再全部做一遍 OpenPGP 签名，再一个个上传，要搞两三个小时，还容易出错，有时候文件名都弄错了。从 2.0 开始我就用脚本了，后来又让 AI 帮我写了一个脚本，自动从 GitHub 下载，让我确认后输入密码做证书签名，再输入密码做 GPG 签名，整理到一个文件夹里，再慢慢传到 GitHub Release，这样快了不少。但是我还是要等流水线构建，一只眼睛看着流水线，一只眼睛做自己的事情。而且我现在住的地方访问 GitHub Release 比较慢，带宽不高，VPN 还限速，就比较痛苦。另外一个痛点是 Nightly 一直没有签名，我不可能每次都下载下来用自己的 GPG 签名，更不可能把 GPG 私钥放到流水线上。</p>
<p>现在的结构是这样的：</p>
<pre class="mermaid">
  flowchart LR
  CI[GitHub Actions] --&gt;|builds| Staging[(Staging bucket)]
  Staging --&gt;|stable builds| Me[Maintainer machine]
  Me --&gt;|signed| Staging
  Staging --&gt; Server[Release server]
  Repo[GpgFrontend repository] --&gt;|policy, trust, scripts| Server
  Server --&gt;|promote| Builds[(Builds bucket)]
  Server --&gt;|signed index| Update[(Update bucket)]
  Builds --&gt; Client[GpgFrontend]
  Update --&gt; Client
</pre>
<p>逐个说明一下：</p>
<ul>
<li>流水线：构建完成后，把产物和 <code>SHA256SUMS.txt</code> 传到 staging 存储桶。它还会用 Sigstore（cosign）对 <code>SHA256SUMS.txt</code> 签名，证明这些文件确实是 GpgFrontend 仓库的 <code>build.yml</code> 流水线在对应的 commit 上构建出来的。这种签名不需要我把任何私钥交给流水线，Nightly 终于有了签名。</li>
<li>staging 存储桶：私有的，不对用户开放，放的是还没有经过检查的东西。</li>
<li>我的电脑：只在稳定版的时候参与。从 staging 下载稳定版的构建，在本地用硬件 token 里的证书给 Windows 安装包做 Authenticode 签名，再用我的 OpenPGP 密钥签名，然后传回 staging。这个证书在硬件 token 里，没法导出，不可能放到云上签名，那样也不安全。</li>
<li>更新服务器：检查 staging 中的东西，检查通过后搬到 builds 存储桶，再更新索引并签名。</li>
<li>builds 存储桶（<code>builds.bktus.com</code>）：放安装包、每个版本的描述文件和 Release Note，用户从这里下载。</li>
<li>update 存储桶（<code>update.bktus.com</code>）：放签过名的索引 <code>index.json</code>，以及根和 index-keys 这些信任相关的文件。</li>
</ul>
<p>为什么要把 builds 和 update 分开？一个是不要把所有东西放在一个篮子里，构建产物和元数据分开放；另外一个是好管理，一个专门放元数据，一个专门放安装包，不会混在一起。再加上 staging，三个存储桶是比较合适的。</p>
<p>更新服务器在中间帮用户把一道关。对于 Nightly、beta 和 RC，它用 cosign 验证 Sigstore 的签名，确认构建来自 <code>build.yml</code>，并且 ref 和 commit 都对得上；每个文件都要和签过名的 <code>SHA256SUMS.txt</code> 一致，不能多出文件；版本号由它自己根据 git 推出来，不相信构建自己声称的版本号。对于稳定版，它还会检查我的 OpenPGP 签名和签过名的 tag，以及 Windows 安装包的 Authenticode 签名者。另外，它会读取仓库里的指导文件 <code>release/policy.toml</code>，比如 2.1 什么时候 EOL，2.2、2.3 现在处于什么状态，生成客户端容易读的元数据，也就是索引。</p>
<p>更新服务器很重要，它决定了客户端能看到什么。但它并不是最致命的一环。它不直接接受客户端的请求，所以也不需要什么高并发、防 DDoS，它只是把东西从未验证的地方搬到已验证的地方，再更新相关的元数据。高可用、高并发、DDoS 防御这些交给 Cloudflare 的基础设施，我自己专门写代码去做这些是一个大工程，也没有必要。所以负载放在存储桶，管理和准入放在更新服务器。而且客户端自己也会做验证，它对更新服务器也是以一种怀疑的态度去看待的，这个后面再说。</p>
<h2 id="签名的根2-of-3-与-minisign">签名的根：2-of-3 与 minisign</h2>
<p>还有一个问题是签名的根。签名的密钥不可能一直不轮换，我总不能 30 年都用同一把密钥。那么怎么管理？我没有用 CA 证书，那样反而更复杂。X.509 我知道它很灵活，可以加各种各样的字段，但是管理它本身就要用到很多工具，OpenSSL 什么的，过于灵活，功能也过多了。只是一个软件更新而已，不需要像 Apple 那样，搞一个 CA 根，自签名，做一个什么仪式，再用 CA 证书去签中间证书，中间证书再去签别的。虽然可以做到，但是没必要。平时用 2-of-3 加上 minisign，就已经完全可以搞定这些东西了。</p>
<p>具体来说：</p>
<ul>
<li>根由 3 把密钥组成，只要其中 2 把签名，就可以进入下一个版本的根。根的有效期是两年，也就是大概两年做一次根的更新，新的根要由旧根和新根里足够数量的密钥签名。</li>
<li>根并不直接签更新服务器的密钥。它指定另外一把离线的密钥，这把密钥不允许是根里的密钥，专门用来签一份 index-keys 列表。这份列表的有效期是一年，里面写明更新服务器可以用哪把密钥来签索引。</li>
<li>更新服务器上只有签索引的那一把 minisign 密钥，没有根密钥，也没有我的 OpenPGP 密钥和 Authenticode 证书。索引的有效期是 14 天，服务器每天重新签一次。</li>
</ul>
<p>所以整条链是：根 → 离线密钥 → index-keys 列表 → 更新服务器上的索引密钥 → <code>index.json</code>。更新服务器的密钥出了问题，或者平时有事没事想换一下，只需要用离线密钥重新签一份列表，不用动根。</p>
<p>这一套我自己不可能手写 JSON，也不可能手动生成三把密钥，再一个个配置上去，所以写了一系列脚本，按照这套机制的设计帮我自动生成，我只需要输入密码。生成的东西会写进项目仓库的 <code>release/root/</code> 和 <code>release/index-keys/</code> 下面，旁边还有可读性更好的文件，面向人类，也就是给我自己，或者其他审查代码的人看的。目前根里的三把密钥是 <code>4E179325A34DCF45</code>、<code>27458E01B54EAF5D</code> 和 <code>4D875241843652E8</code>。</p>
<p>为什么用 minisign，而不是 OpenPGP？GpgFrontend 本身就是一个 OpenPGP 的工具，这个问题很自然。问题在于 OpenPGP 需要先准备一个上下文（context）才能用，密钥管理相对比较复杂，而且它一般是和人的身份绑定的，不是随便就能生成一把新的，用子密钥就更复杂了。说到底，OpenPGP 主要还是给个人用户在各种场景下用的。对于机器读、客户端自己验证这种场景，最好就是依赖的上下文尽量小。minisign 的验证用 libsodium 就可以实现，不需要引入整个 GnuPG 或者 RPGP，也不需要 GpgFrontend 自己的 context 去加载什么，轻量的就可以用。而且这里只需要验证，只认密钥本身，不需要像个人身份那样还要看 User ID。所以最终用了 minisign。</p>
<p>但是底线还在。稳定版最终还是会用我离线的 OpenPGP 密钥签名，不管怎么自动化，稳定版都要我本人确认这个版本，手动输入密码，用硬件 token 里的密钥做签名。这把 OpenPGP 密钥和我的身份绑定在一起，是受到别人信任的，指纹是 <code>12F7E8858CF15BEC9975FF3C5CA3DA246843FD03</code>。这是最后一道防线，回到这个项目的宗旨上，我觉得已经足够了。</p>
<h2 id="客户端不盲信更新服务器">客户端：不盲信更新服务器</h2>
<p>在新的机制下，客户端的逻辑可以少一些，更多地由更新服务器提供的元数据来决定：现在有哪些版本线，哪条线处于什么状态，有哪些 beta 可以用，该推荐哪个版本。更新服务器可以根据安全或者其他方面的考量调整这些，以后版本号或者版本线变化了，也可以比较容易地指导客户端，而不会出现规则一变，旧的客户端就用不了的情况。</p>
<p>但是客户端不能盲目听信更新服务器。更新服务器本身可能被攻破，它的签名密钥也可能被窃取。所以客户端在编译的时候就自带了根，拿到索引以后自己验证：</p>
<ul>
<li>从自带的根出发，一步步走到最新的根，每一步都要满足 2-of-3，再检查 index-keys 列表，确认签索引的那把密钥在列表里；</li>
<li>验证 <code>index.json</code> 的 minisign 签名，检查它有没有过期；</li>
<li>检查索引的序号，不允许回滚到旧的索引；</li>
<li>用索引里的 sha256 检查每个版本的描述文件和 Release Note，下载的文件再用描述文件里的 sha256 检查。</li>
</ul>
<p>如果更新服务器被攻破了，或者做了什么恶意的事情，客户端验证不通过，大不了拒绝它。你只是没法方便地自动更新了，但还是可以手动去下载页或者 GitHub 上下载。</p>
<p>Release Note 现在也独立出来了，不再在 GitHub Release 里管理，而是放在仓库的 <code>release/notes/</code> 目录下。它需要用我的 OpenPGP 密钥签名后才能发布，它的 hash 写在签过名的索引里。里面的链接也有管控，只允许 https 的 <code>bktus.com</code> 及其子域名，还有 GitHub 上的 GpgFrontend 仓库，不能随便链接到其他无关的、可能是恶意的网址，不符合要求的链接只会显示成纯文本。</p>
<p>自动安装方面，目前 Linux 上 Nightly 的 AppImage 已经可以在更新窗口里点“安装”，下载的文件必须和描述文件里的大小、sha256 一致才会替换。稳定版以后再看看怎么安全地做自动安装，这样既方便用户，又能确保安全。</p>
<h2 id="同一套脚本gfrelease">同一套脚本：gfrelease</h2>
<p>这一套模型有一系列脚本，就放在 GpgFrontend 的仓库里（<code>scripts/gfrelease</code>），它是整个模型的具体实现。更新服务器直接复用这套脚本做检查、处理元数据；我自己也用同一套脚本，比如更新根、更新 index-keys 列表，还有把稳定版的构建下载到本地签名再传回 staging。也就是说，不是更新服务器自己有一套实现，我另外有一套，而是我们共同使用同一套基于这个模型的实现。更新服务器自己只有一些外围的东西，比如让它不要挂掉的部分、Dockerfile，还有一个可以让我一眼看到当前状态的 Web 页面。核心的东西，包括模型本身的实现、各种验证、OpenPGP 的验证，都在代码仓库里，所有人都能看到，都能审查。</p>
<p>更新服务器本身的仓库，我刚开始是想开源的，但后来又不想了。因为它涉及到我自己服务器上的一些配置，有人掌握了这些配置，可能在攻破之后更容易找到其他的东西。Dockerfile 本身没什么问题，但是 compose 文件里有环境变量，万一意外上传了什么密钥之类的，就比较麻烦。它本身就是很薄的一层，所以选择不开源。</p>
<p>那么我承诺它用的是仓库里的这套脚本，这个承诺算不算数呢？我也没法自证。虽然理论上我可以不用这些脚本，但实际上我是会用的，不过个人的承诺并不算什么。在安全软件这方面，没有“我说它是安全的，你就要无条件听我的”这种事情，这是不成立的。所以你可以去审查仓库里存的根和相关的公钥，检查你的客户端里带的是不是仓库中你认可的那个 commit 的公钥，也可以自己去验证更新服务器推到存储桶里的东西。不管更新服务器有没有被攻破，你都能看得到。</p>
<h2 id="更新检查会发什么不会发什么">更新检查会发什么，不会发什么</h2>
<p>这一部分我觉得需要单独说清楚：</p>
<ul>
<li>更新检查默认是关闭的。第一次启动时的设置向导里有一个检查更新的选项，默认不勾。打开以后，它一天检查一次。你也可以在 Help &gt; Check for Updates 里手动检查。</li>
<li>客户端只发 HTTPS GET 请求，访问的是 <code>update.bktus.com</code> 和 <code>builds.bktus.com</code> 这两个存储桶的域名，不访问 GitHub，也没有其他额外的服务器。</li>
<li>请求里没有用户 ID，也没有机器 ID，没有请求体，User-Agent 是一个固定的、通用的浏览器字符串。操作系统版本、架构这些信息只在本地用来挑选合适的文件，不会发出去。</li>
<li>需要注意的一点：最后一个请求是 <code>commits/&lt;commit&gt;</code>，路径里带着你这个构建的 commit，用来确认这个构建是不是来自官方仓库。所以服务器那边能知道你运行的是哪个构建，也就能知道是哪个版本，虽然版本号本身不会发送。</li>
<li>和任何 HTTPS 请求一样，服务器能看到你的 IP 地址。存储桶在 Cloudflare 上，Cloudflare 会按照它自己的规则处理和保留这些请求数据。我自己没有做任何访问数据的收集和分析，也没有必要做这样的事情。</li>
</ul>
<p>现在我人在欧盟，在欧盟的法律框架下，这些需要公开说明。所以后续我会更新一版新的隐私政策，让它符合法律，并在文档中解释更新检查到底会访问什么、会发送什么请求。</p>
<h2 id="这套东西是怎么做出来的">这套东西是怎么做出来的</h2>
<p>从最初的版本发布模型到现在的实现，你可以在提交记录里看到，即使有 AI 辅助，我也来来回回搞了好几轮。先是提出一个想法，让 AI 看看能不能先做一个简单的实现；后面发现这个实现有些地方不符合软件架构的原则，或者有 bug，让它修；修完之后在 Nightly 上用，发现好像不太 OK，再改；后来又想到以后其他版本线或者 beta 怎么办，再改。改完之后，还要让它重新检查一遍有没有问题，代码写得好不好，比如某个地方已经有可以用的东西了，它又在另外一个地方写了一份，又写了一个计算哈希的函数，这些都需要让它自查。</p>
<p>我自己也会看它提交的代码，看有没有坏味道（code smell），是不是符合我对这个模型的认知。AI 在几轮下来的过程中，可能会用另一种你不喜欢的方式去实现你想的东西，或者直接误解了你的意思，这个是需要自己把关的。</p>
<h2 id="后记">后记</h2>
<p>从 2.2.5 开始，包括现在的主线，最主要的版本管理都已经转移到了新的模型和机制上。仓库里的指导文件、流水线、更新服务器、存储桶、客户端，再加上我自己的电脑，各自分工，高内聚、低耦合，这也算是我个人经验的一个体现。GitHub Release 现在作为镜像继续保留。我感觉这套机制是够用的，未来很长一段时间应该都不用再大改，小修小补可能会有。</p>
<p>具体的使用方法和细节，可以看用户手册里的<a href="https://gpgfrontend.bktus.com/appendix/version-policy/">版本号规则</a>、<a href="https://gpgfrontend.bktus.com/appendix/release-updates/">发布与更新的工作方式</a>、<a href="https://gpgfrontend.bktus.com/appendix/code-binary-verify/">如何验证下载的文件</a>，还有<a href="https://gpgfrontend.bktus.com/overview/downloads/">下载页</a>。</p>
<p>大概就是这些。这篇文章主要解释为什么要做新的版本模型和机制，以及背后的一些基础想法。文章是我口述的，再让 AI 整理，整理过后我检查了是不是符合我的想法、有没有偏离原意，并不是让 AI 扫一下仓库一键生成的。我不太喜欢打字，现在可以口述，写文章也比较容易了，所以也不需要一次把所有东西都说完。后续有什么新的想法，会继续写文章，这些文章也会链接到 Release Note 或者用户手册里，帮助用户理解每天这么多 commit 到底在更新些什么，我又在想些什么。如果有错误或者疑问，欢迎指出。</p>
]]></content:encoded></item><item><title>没有巴德膜的日偏食：一台四不像“投影仪”的观测记录</title><link>https://blog.bktus.com/archives/tcoudk/</link><pubDate>Wed, 12 Aug 2026 21:30:00 +0200</pubDate><guid>https://blog.bktus.com/archives/tcoudk/</guid><description>&lt;p>2026 年 8 月 12 日有一次日全食，全食带从北冰洋经过冰岛，最后在西班牙结束。我所在的地方大概在北纬 49 度，不在全食带内，只能看到一次食分比较深的日偏食：太阳最多被遮住 88.9%，本地食甚大约在 20:15，可见的时段从 19:22 持续到 20:47，几乎是贴着日落。也就是说，整个过程都发生在太阳高度角不到 10 度的傍晚，观测窗口比较低。&lt;/p></description><content:encoded><![CDATA[<p>2026 年 8 月 12 日有一次日全食，全食带从北冰洋经过冰岛，最后在西班牙结束。我所在的地方大概在北纬 49 度，不在全食带内，只能看到一次食分比较深的日偏食：太阳最多被遮住 88.9%，本地食甚大约在 20:15，可见的时段从 19:22 持续到 20:47，几乎是贴着日落。也就是说，整个过程都发生在太阳高度角不到 10 度的傍晚，观测窗口比较低。</p>
<p><img alt="Info" loading="lazy" src="https://img.bktus.com/EZ4v5cdu.webp"></p>
<h2 id="没有巴德膜怎么办">没有巴德膜怎么办</h2>
<p>观测日食，正经的做法是在望远镜或者双筒镜的物镜前加一片巴德膜，把阳光衰减到安全的亮度再直接看。但是我手头没有，临时买也来不及了，所以只剩下一条经典的路：投影法。也就是说，不用眼睛去看目镜，而是让望远镜把太阳的像投到一张白纸上，看纸上的像。这个方法对器材没有什么特殊要求，唯一需要注意的是，全程绝对不能把眼睛凑到目镜后面。</p>
<p>所以我把手头能用的东西都凑到了一起：一副 7x50 的双筒望远镜、一个旅行三脚架、一个球形云台，再加上快装板和 L 板拼出来的连接件。双筒镜侧躺着夹在架子上，镜身朝天，目镜那一端斜着指向地面。这套东西没有一个零件是为这个用途设计的，组合出来的样子也比较离谱，但是它能稳定地指向太阳，也能微调跟踪，这就够了。</p>
<p><img alt="Equipments" loading="lazy" src="https://img.bktus.com/GVDzzrDF.webp"></p>
<p>对准太阳也有讲究。不能通过目镜去瞄准，我用的是看影子的办法：调整镜身的姿态，直到双筒镜投在地面上的影子缩到最小、最对称，这个时候太阳就进入视场了。然后在目镜后方二三十厘米的地方举一张白纸，慢慢前后移动找焦点，纸上就会出现一个明亮、清晰的太阳像。</p>
<h2 id="纸上的日食">纸上的日食</h2>
<p>食甚前后，纸上的太阳已经缺成了一弯细细的月牙。双筒镜和云台的影子也投在纸上，中间就是这一弯亮弧，旁边甚至还能看到目镜杂散光形成的几个小像。傍晚的阳光本来就偏金黄，整个画面意外地好看。</p>
<p><img alt="Sun" loading="lazy" src="https://img.bktus.com/xF66KRze.webp"></p>
<p><img alt="Sun" loading="lazy" src="https://img.bktus.com/1ZGJUwt0.webp"></p>
<p><img alt="Sun" loading="lazy" src="https://img.bktus.com/tkRQjj2I.webp"></p>
<p>我选的观测点是一座电车站的高架平台，视野开阔，正对着西边的低空。到了傍晚，平台上陆陆续续聚了不少人，有戴日食眼镜的，有支着相机和脚架的，也有路过停下来看一眼投影纸的。白纸一直举在我手里，纸上的月牙比任何解说都直观，不时还有路人举起手机对着它拍照，拍出来的效果居然都还不错。</p>
<p>还有一个和直觉不太一样的发现：即使食分已经接近 88%，用肉眼看太阳还是很刺眼，眯起眼睛也只能勉强看出一点月牙的轮廓。我原本以为太阳被遮掉近九成，天会像黄昏一样暗下来，实际上天色只是稍微暗了一点，太阳本身还是亮得没法看。说白了，剩下那一成多的日面，亮度还是远远超出了眼睛能承受的范围。后来有路人主动把日食眼镜借给我戴，我才真正看到了它的全貌。</p>
<p><img alt="People" loading="lazy" src="https://img.bktus.com/PrYEDBJG.webp"></p>
<h2 id="几点记录">几点记录</h2>
<p>投影法的效果比我预想的好。7x50 的口径集光比较足，投出来的像亮度和锐度都够，月牙的边缘也很干净。凑近仔细看，纸上甚至能认出两三个黑子，一副 7 倍的双筒镜能做到这一步，是我完全没有想到的。代价就是跟踪要勤，太阳在低空一边移动一边下沉，隔一两分钟就得拧一下云台。另外，投影端的温度会升高，我每隔一段时间就把物镜盖盖上，让它歇一会儿，以免目镜组件长时间被聚焦的阳光烤着。</p>
<p>这次没有巴德膜，反而成了一件好事。直接看是一个人的事，投影法却把太阳摊在一张纸上，谁走过来都能看。以后有条件的话，我计划专门坐飞机去全食带看一次日全食，到时候应该能带上完整的观测设备。</p>
]]></content:encoded></item><item><title>搭建一个可分流的个人VPN网关：WireGuard、sing-box与Gluetun的组合实践</title><link>https://blog.bktus.com/archives/vr4bm4/</link><pubDate>Sat, 23 May 2026 00:35:00 +0200</pubDate><guid>https://blog.bktus.com/archives/vr4bm4/</guid><description>&lt;p>在&lt;a href="https://blog.bktus.com/archives/ozzkto/">之前的文章&lt;/a>中，我介绍过一种比较直接的链式 VPN 方案：所有设备先连接到自己搭建的WireGuard 服务器，再由服务器把流量转发到 Gluetun，最终通过上游 VPN 服务商的出口访问互联网。&lt;/p>
&lt;p>这个方案的核心价值很明确：&lt;/p></description><content:encoded><![CDATA[<p>在<a href="https://blog.bktus.com/archives/ozzkto/">之前的文章</a>中，我介绍过一种比较直接的链式 VPN 方案：所有设备先连接到自己搭建的WireGuard 服务器，再由服务器把流量转发到 Gluetun，最终通过上游 VPN 服务商的出口访问互联网。</p>
<p>这个方案的核心价值很明确：</p>
<ul>
<li>所有设备只需要配置一个 WireGuard；</li>
<li>上游 VPN 只需要在服务器端维护；</li>
<li>可以把手机、电脑、平板、家用设备统一接入同一个虚拟局域网；</li>
<li>出口 IP 由商业 VPN、公司 VPN 或其他上游 VPN 提供，而不是直接暴露 VPS IP；</li>
<li>整套系统可以通过 Docker 部署，尽量不污染宿主机环境。</li>
<li>相比于直连VPN，该方案下VPN服务商能看到的只是你的VPN网关出口（你的VPS服务器），而不是每个设备的真实 IP。</li>
<li>另外，本地的ISP等也看不到你是否是在使用主流VPN，因为他们只能知道你在连接到一个
VPN网关（你的VPS服务器），但流量最终去了哪里是未知的。</li>
</ul>
<p>不过，随着使用场景变多，原来的结构也逐渐暴露出一些局限。最典型的问题是，对流量的控制不够细粒度。默认情况下所有流量都必须进入上游 VPN 隧道，这对于某些服务可能会触发风控，或者导致访问问题。而且比较难方便地进行流量工程，对不同服务采用不同的出口策略。原先通过 iptables 和路由表的方式虽然能实现分流，但规则一多就难维护。</p>
<p>所以，我把原来的方案重新整理成了一个更完整的个人 VPN 网关架构。新版方案不再只是简单的 <code>WG-Easy + Gluetun</code>，而是变成了：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>WG-Easy + sing-box + Gluetun + AdGuard Home + config.yaml 统一配置生成
</span></span></code></pre></div><p>对我来说，这套方案已经不只是“VPN 套 VPN”，而是一个可以长期维护、可扩展、可观察的个人网络出口。它既可以服务日常上网，也可以服务远程办公、家庭内网访问、开发测试和多设备统一管理。如果你只需要最简单的全局 VPN 转发，旧版思路仍然够用。但如果你希望在隐私、可控性、分流规则和 DNS 管理之间取得更好的平衡，新版架构会更合适。</p>
<p>这篇文章会介绍新版架构的设计思路、流量路径、适合的使用场景，以及相比旧方案的主要改进。如果你对新版方案感兴趣，或者想直接部署使用，可以直接查看<a href="https://github.com/saturneric/wg-easy-gluetun">我在 GitHub 上的项目仓库</a>。</p>
<h2 id="为什么需要新版架构">为什么需要新版架构</h2>
<p>最早的链式 VPN 方案其实已经能解决很多问题。比如我在家里、办公室、外出网络中都可以使用同一个 WireGuard 配置接入 VPS，然后通过 VPS 上的 Gluetun 进入上游 VPN。这样所有设备都共享同一个上游 VPN 出口，也能避免在每台设备上反复安装、登录、配置不同 VPN 客户端。</p>
<p>这个方案实际我平时使用下来也很稳定，性能也能够满足我的需求，基本上没有什么大问题。但长时间使用下来，我还是遇到了几大痛点。</p>
<h3 id="不是所有流量都适合走上游-vpn">不是所有流量都适合走上游 VPN</h3>
<p>我在实际的使用中发现，某些服务可能会因为 VPN 出口触发风控，例如账号登录、支付、AI 服务等。比如一些我常用的流媒体平台，对于VPN有着严格的限制，有时这些流量更适合直连。还有就是，我有时候需要网文在校园网内部的课程服务器，有时候会涉及远程桌面，这需要比较低的延迟。这种情况下，走VPN的话即使是本国出口体验也非常不佳。</p>
<p>所以，我希望能有更细粒度的分流能力。比如通过规则集把我信任的一些服务的流量绕过上游 VPN，直接从服务器侧访问互联网。这样既能保持上游 VPN 的隐私保护，又能避免一些不必要的访问问题。以前的做法更多依赖 iptables、路由表和容器网络。能工作，但规则一多就难维护。</p>
<p>在通过调研和测试后，我发现 sing-box 的 TUN 模式非常适合做这种基于规则的分流。它支持丰富的规则类型和灵活的路由策略，可以根据域名、IP等多维度来决定流量的下一跳。通过把 sing-box 放在 WG-Easy 和 Gluetun 之间，我就能实现更智能的流量分流，而不是简单的全局 VPN。然后singbox能够引用远程的规则集，例如
geosite-openai、geosite-paypal 等，这样我就不需要自己维护这些规则了。还有就是，
相比于部署一个openwrt虚拟机，singbox的部署和维护都更轻量级，对docker更友好。</p>
<p>如此一来，我就能够更灵活地进行流量工程了。比如：默认流量，为了隐私保护需要它们走
VPN。而有些在特定区域的服务，我希望从另外的VPN 出口访问；有些服务我希望直接访问；有些服务我希望通过特定的 VPN 出口访问。通过sing-box 的规则分流，我可以更方便地实现这些策略。</p>
<h3 id="配置需要集中管理">配置需要集中管理</h3>
<p>原先仓库中配置都是分散在conf目录下，修改网段的等配置本来就不太方便。在加入
sing-box后，Docker Compose、wg-easy hook、sing-box JSON、AdGuardHome 配置、iptables 规则一起维护，就比较痛苦了。所以，新版方案我用<code>config.yaml</code> 作为单一配置入口，再通过模板生成 runtime 文件。</p>
<p>每次修改配置后，直接运行生成<code>up.sh</code>脚本就能把所有相关配置文件更新到位，避免了“改了这个忘了改那个”的问题。</p>
<h3 id="更完善的网络监控">更完善的网络监控</h3>
<p>原来的方案主要依赖日志来观察网络状态。我有时候像看一下当前有哪些设备现在连接了
WireGuard，这些设备都会访问什么服务，有没有异常流量等。在原先的方案里，这些信息都需要自己在容器里查看日志，或者额外安装一些监控工具。新版方案通过singbox提供的
API接口，可以配合MetaCubeXD等工具来实时查看流量分布、规则命中、上游访问等信息，
提升了可观测性。</p>
<p>所以，新版架构的目标并不只是单纯地“再套一层 VPN”，我想要的是构建一个更像家庭或个人使用的可控网络出口。</p>
<h2 id="新版方案的组件">新版方案的组件</h2>
<p>新版方案主要由四个核心容器组成。</p>
<h3 id="wg-easywireguard-接入层">WG-Easy：WireGuard 接入层</h3>
<p>WG-Easy 仍然负责最基础也最重要的部分：提供 WireGuard 服务端和 Web 管理界面。所有手机、电脑、平板、服务器都作为 WireGuard 客户端连接到 WG-Easy。用户可以通过
WG-Easy 的 Web UI 创建 peer、下载配置文件或扫码导入手机端。</p>
<p>在新版架构中，WG-Easy 不再只是把流量直接交给 Gluetun，而是通过 hook 和 policy
routing 把客户端流量导入更复杂的网关路径。</p>
<h3 id="adguard-home统一-dns-与过滤层">AdGuard Home：统一 DNS 与过滤层</h3>
<p>AdGuard Home 负责 DNS 解析、广告过滤、跟踪域名拦截和 DNS 查询日志。</p>
<p>新版架构中，来自 WireGuard 客户端的普通 DNS 请求会被限制到 AdGuard Home。也就是说，客户端不能随便把 DNS 发到 <code>8.8.8.8</code>、<code>1.1.1.1</code> 或其他外部 DNS 服务器。</p>
<p>这样做的好处是：</p>
<ul>
<li>可以集中设置上游 DNS；</li>
<li>可以统一管理过滤列表；</li>
<li>可以查看客户端 DNS 查询；</li>
<li>可以降低 DNS 泄露风险；</li>
<li>可以避免每台设备单独配置过滤软件。</li>
</ul>
<p>当然，这并不等于可以完全阻止所有形式的 DNS 绕过。比如 DoH、DoT 或某些应用内置解析仍然需要额外策略处理。但对于普通 UDP/TCP 53 DNS 请求，网关可以做到统一收口。</p>
<h3 id="sing-box规则分流层">sing-box：规则分流层</h3>
<p>sing-box 是新版架构中最关键的变化。</p>
<p>它通过 TUN inbound 接收 WG-Easy 转发过来的流量，然后根据规则决定下一跳：</p>
<ul>
<li>命中 <code>bypass_rule_sets</code> 的流量直接出站；</li>
<li>私有 IP 流量直接出站，避免误送进上游 VPN；</li>
<li>其他默认流量打上 routing mark，交给 Linux policy routing，再进入 Gluetun；</li>
<li>规则集可以使用远程 <code>.srs</code> 文件，例如 geosite-openai、geosite-paypal 等。</li>
</ul>
<p>如果你看对应的singbox的配置文件，会发现一个比较奇怪的点：sing-box 里的 <code>gluetun</code>
outbound 在配置上也是 <code>direct</code>类型，但它带有 <code>routing_mark</code>。实际上，这个 mark
会被Linux policy routing 捕获，把流量导向 Gluetun。所以说，它并不是普通意义上的直连，其实是“通过系统路由送到 Gluetun”。</p>
<p>说白了，sing-box 在这里更像一个智能分流器，而 Gluetun 是最终的上游 VPN 出口。这里除了通过gluetun，singbox自己也可以通过类似的方式配置其他类型的 outbound，例如 WireGuard、VLESS、Trojan 等，来适配更多样化的上游服务。如果你不需要gluetun提供的各种便利性服务，甚至可以在这里就把它换成其他 VPN 客户端或直接的互联网出口。</p>
<p>需要注意的是，singbox在这里是拿不到域名信息，所以我们在这里需要开启sniff
功能来识别域名。这样才能基于域名的规则集来做分流。对于一些不支持sniff的协议或加密流量，可能就只能基于IP规则来做分流了。</p>
<h3 id="gluetun上游-vpn-出口层">Gluetun：上游 VPN 出口层</h3>
<p>Gluetun 负责连接商业 VPN、公司 VPN 或其他支持的上游 VPN 服务。</p>
<p>它的优势是支持大量 VPN 服务商，并且把 OpenVPN / WireGuard 客户端、认证参数、防火墙规则、健康检查等逻辑都封装在容器里。</p>
<p>在新版架构中，绝大多数默认流量最终都会进入 Gluetun，再由 Gluetun 通过上游 VPN 隧道访问互联网。这样客户端看到的是自己的 WireGuard 网络，而互联网看到的是上游 VPN
的出口 IP。</p>
<h2 id="整体网络拓扑">整体网络拓扑</h2>
<p>新版架构可以理解为下面这个路径：</p>
<pre class="mermaid">
  flowchart TD
  subgraph devices[&#34;Your Devices&#34;]
    phone[&#34;Phone&#34;]
    pc[&#34;PC&#34;]
    laptop[&#34;Laptop&#34;]
  end

  subgraph server[&#34;Your Server&#34;]
    wgeasy[&#34;WG-Easy (WireGuard Server)&#34;]
    adguard[&#34;AdGuard Home (DNS Filtering)&#34;]
    singbox[&#34;sing-box (TUN Router / Rule Engine)&#34;]
    gluetun[&#34;Gluetun (VPN Provider Client)&#34;]
  end

  phone -- WireGuard --&gt; wgeasy
  pc -- WireGuard --&gt; wgeasy
  laptop -- WireGuard --&gt; wgeasy

  wgeasy -- DNS only --&gt; adguard
  wgeasy -- regular traffic --&gt; singbox
  singbox -- bypass_rule_sets --&gt; direct[&#34;Direct Internet&#34;]
  singbox -- default route --&gt; gluetun
  gluetun -- VPN tunnel --&gt; provider[&#34;VPN Provider&#34;]
  provider --&gt; internet[&#34;Internet&#34;]
  direct --&gt; internet
</pre>
<p>从流量角度看，可以分成三类：</p>
<ol>
<li><strong>DNS 流量</strong>：WireGuard 客户端的 DNS 请求被固定转发到 AdGuard Home。</li>
<li><strong>命中绕过规则的流量</strong>：例如 OpenAI、PayPal 或其他你放进 <code>bypass_rule_sets</code> 的规则集，可以走 direct。</li>
<li><strong>默认流量</strong>：没有命中绕过规则的普通互联网流量会进入 Gluetun，再通过上游 VPN 出口访问互联网。</li>
</ol>
<p>另外，还可以配置 <code>direct_subnets</code>，让特定网段绕过 sing-box。这适合一些明确的内网访问场景，例如访问家庭局域网、特定 Docker 网络或某些专用子网。</p>
<h2 id="配置管理从手写配置到生成式配置">配置管理：从手写配置到生成式配置</h2>
<p>新版方案的另一个重要变化是配置管理方式。</p>
<p>以前你可能需要同时修改：</p>
<ul>
<li><code>docker-compose.yml</code></li>
<li>WireGuard hook</li>
<li>iptables 规则</li>
<li>Gluetun 环境变量</li>
<li>DNS 配置</li>
<li>sing-box JSON</li>
<li>AdGuard Home 配置</li>
</ul>
<p>这样虽然灵活，但维护成本很高。尤其是网络结构稍微变化后，很容易出现“一个地方改了，另一个地方忘了改”的问题。新版方案把主要配置集中到<a href="https://github.com/saturneric/wg-easy-gluetun/blob/master/config.yaml"><code>config.yaml</code></a>，
然后通过生成脚本把它渲染成 runtime/ 下的各种实际的配置文件。</p>
<p>所以，普通用户只需要改 <code>config.yaml</code>。而高级用户如果要调整更多的配置，则可以修改<code>templates/</code> 下的 Jinja2 模板。这样既保证了配置的集中管理，也保留了足够的灵活性。</p>
<p>需要注意的是，我建议不要直接修改 <code>runtime/</code> 目录下的文件。它们是生成物，每次重新运行都会被覆盖。</p>
<h2 id="sing-box-分流规则如何工作">sing-box 分流规则如何工作</h2>
<p>新版方案中，sing-box 的规则大致可以理解为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-json" data-lang="json"><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&#34;route&#34;</span>: {
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">&#34;rules&#34;</span>: [
</span></span><span style="display:flex;"><span>      { <span style="color:#f92672">&#34;inbound&#34;</span>: <span style="color:#e6db74">&#34;tun-in&#34;</span>, <span style="color:#f92672">&#34;action&#34;</span>: <span style="color:#e6db74">&#34;sniff&#34;</span> },
</span></span><span style="display:flex;"><span>      { <span style="color:#f92672">&#34;ip_is_private&#34;</span>: <span style="color:#66d9ef">true</span>, <span style="color:#f92672">&#34;outbound&#34;</span>: <span style="color:#e6db74">&#34;direct&#34;</span> },
</span></span><span style="display:flex;"><span>      {
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&#34;rule_set&#34;</span>: [<span style="color:#e6db74">&#34;geosite-openai&#34;</span>, <span style="color:#e6db74">&#34;geosite-paypal&#34;</span>],
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&#34;outbound&#34;</span>: <span style="color:#e6db74">&#34;direct&#34;</span>
</span></span><span style="display:flex;"><span>      },
</span></span><span style="display:flex;"><span>      { <span style="color:#f92672">&#34;outbound&#34;</span>: <span style="color:#e6db74">&#34;gluetun&#34;</span> }
</span></span><span style="display:flex;"><span>    ]
</span></span><span style="display:flex;"><span>  }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>这表示：</p>
<ol>
<li>先对流量做 sniff，识别域名等信息；</li>
<li>私有 IP 地址直接走 direct；</li>
<li>命中规则集的流量走 direct；</li>
<li>其他所有流量走 <code>gluetun</code> outbound。</li>
</ol>
<p><code>bypass_rule_sets</code> 的含义是“绕过上游 VPN”，不是“绕过你的服务器”。</p>
<p>例如你配置了：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-yaml" data-lang="yaml"><span style="display:flex;"><span><span style="color:#f92672">singbox</span>:
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">bypass_rule_sets</span>:
</span></span><span style="display:flex;"><span>    - <span style="color:#f92672">tag</span>: <span style="color:#e6db74">&#34;geosite-openai&#34;</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">url</span>: <span style="color:#e6db74">&#34;https://raw.githubusercontent.com/SagerNet/sing-geosite/rule-set/geosite-openai.srs&#34;</span>
</span></span><span style="display:flex;"><span>    - <span style="color:#f92672">tag</span>: <span style="color:#e6db74">&#34;geosite-paypal&#34;</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">url</span>: <span style="color:#e6db74">&#34;https://raw.githubusercontent.com/SagerNet/sing-geosite/rule-set/geosite-paypal.srs&#34;</span>
</span></span></code></pre></div><p>那么这些服务的流量仍然会经过你的 WireGuard 服务器和 sing-box，只是不再进入
Gluetun 的上游 VPN 隧道，而是由服务器侧直接访问互联网。</p>
<p>这对一些对 VPN 出口敏感的服务很有帮助。比如有些服务看到商业 VPN IP 会要求额外验证，甚至直接拒绝访问。通过规则绕过上游 VPN 后，可以减少这类问题。</p>
<h2 id="extra_rule_sets-是什么">extra_rule_sets 是什么</h2>
<p>新版配置里还有一个 <code>extra_rule_sets</code>：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-yaml" data-lang="yaml"><span style="display:flex;"><span><span style="color:#f92672">singbox</span>:
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">extra_rule_sets</span>:
</span></span><span style="display:flex;"><span>    - <span style="color:#f92672">tag</span>: <span style="color:#e6db74">&#34;geosite-google&#34;</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">url</span>: <span style="color:#e6db74">&#34;https://raw.githubusercontent.com/SagerNet/sing-geosite/rule-set/geosite-google.srs&#34;</span>
</span></span><span style="display:flex;"><span>    - <span style="color:#f92672">tag</span>: <span style="color:#e6db74">&#34;geosite-apple&#34;</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">url</span>: <span style="color:#e6db74">&#34;https://raw.githubusercontent.com/SagerNet/sing-geosite/rule-set/geosite-apple.srs&#34;</span>
</span></span></code></pre></div><p>它的作用是：下载并缓存这些规则集，但不参与当前路由匹配。也就是说，<code>extra_rule_sets</code> 不会改变流量路径。只有放进 <code>bypass_rule_sets</code>，或者在
sing-box 模板里显式引用，规则才会真正生效。</p>
<p>我保留这个配置项，是为了方便未来扩展。例如我可能想先把 Google、Apple、Amazon 等规则集准备好，但不马上启用。等到需要时，只需要把对应规则移到<code>bypass_rule_sets</code>，或者添加新的 route rule。</p>
<p>如果你追求最简配置，也可以把 <code>extra_rule_sets</code> 设置成空数组：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-yaml" data-lang="yaml"><span style="display:flex;"><span><span style="color:#f92672">singbox</span>:
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">extra_rule_sets</span>: []
</span></span></code></pre></div><p>注意，YAML 中最好写成显式空数组，而不是只写一个空 key：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-yaml" data-lang="yaml"><span style="display:flex;"><span><span style="color:#75715e"># 推荐</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">extra_rule_sets</span>: []
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e"># 不推荐，容易被解析成 null</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">extra_rule_sets</span>:
</span></span></code></pre></div><h2 id="dns为什么要默认引入-adguard-home">DNS：为什么要默认引入 AdGuard Home</h2>
<p>在 VPN 网关中，DNS 是一个很容易被忽略的问题。如果只管普通流量，不管 DNS，就可能出现这种情况：</p>
<ul>
<li>浏览器流量走了你的 VPN 网关；</li>
<li>DNS 查询却发给了本地网络、运营商 DNS 或某个公共 DNS；</li>
<li>最终造成 DNS 泄露，或者规则分流判断不准确。</li>
</ul>
<p>新版架构里，WireGuard 客户端的普通 DNS 请求会被限制到 AdGuard Home。这样你可以在网关侧统一管理 DNS。</p>
<p>AdGuard Home 可以带来几个好处：</p>
<ul>
<li>广告和跟踪域名过滤；</li>
<li>自定义上游 DNS；</li>
<li>查询日志；</li>
<li>本地域名重写；</li>
<li>对不同客户端做差异化策略。</li>
</ul>
<p>不过需要注意，如果你想完全禁止所有 DNS 绕过，还需要考虑 DoH/DoT/QUIC等情况。本文中的 DNS 限制主要针对传统 UDP/TCP 53 查询。</p>
<h2 id="适合的使用场景">适合的使用场景</h2>
<p>新版架构可以覆盖的场景比旧版更多，综合考虑下，主要适用于以下几种情况：</p>
<h3 id="1-多设备共享一个上游-vpn">1. 多设备共享一个上游 VPN</h3>
<p>这是最基础的使用方式。</p>
<p>你只需要在服务器上配置一次上游 VPN，所有设备通过 WireGuard 接入。手机、电脑、平板、备用机都不需要分别安装上游 VPN 客户端。</p>
<p>这对于设备数量较多、平台较杂，或者上游 VPN 客户端体验不佳的情况尤其有用。</p>
<h3 id="2-远程访问家庭或办公网络">2. 远程访问家庭或办公网络</h3>
<p>所有设备接入同一个 WireGuard 网络后，可以形成一个统一的虚拟局域网。</p>
<p>你可以用它访问：</p>
<ul>
<li>家里的 NAS；</li>
<li>办公室内网服务；</li>
<li>私有 Git 服务；</li>
<li>家庭媒体服务器；</li>
<li>SSH 管理入口。</li>
</ul>
<p>如果配合 <code>direct_subnets</code>，还可以让部分内网访问不经过复杂的 sing-box 分流逻辑。</p>
<h3 id="3-对不同服务采用不同出口策略">3. 对不同服务采用不同出口策略</h3>
<p>有些服务适合走商业 VPN，有些服务则不适合。</p>
<p>例如：</p>
<ul>
<li>默认流量走 Gluetun 上游 VPN；</li>
<li>OpenAI、PayPal 等敏感服务走 direct；</li>
<li>Torrent、P2P 流量走Gluetun或者其他专门的 VPN 出口；</li>
<li>私有 IP 和内网地址不进入上游 VPN；</li>
<li>特定规则集预先下载，但暂不启用。</li>
</ul>
<p>这种结构比旧版本的“全局代理”更灵活，也比纯手写 iptables 规则更容易维护。</p>
<h3 id="5-低侵入式部署">5. 低侵入式部署</h3>
<p>整套方案基于 Docker Compose。宿主机只需要安装 Docker 和 Docker Compose，主要网络逻辑都在容器和生成配置中完成。这对 VPS、家用服务器、软路由、树莓派都比较友好。</p>
<h2 id="部署流程概览">部署流程概览</h2>
<p>实际部署时，流程大致是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-shell" data-lang="shell"><span style="display:flex;"><span>git clone https://github.com/saturneric/wg-easy-gluetun.git
</span></span><span style="display:flex;"><span>cd wg-easy-gluetun
</span></span></code></pre></div><p>然后编辑：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-shell" data-lang="shell"><span style="display:flex;"><span>vim config.yaml
</span></span></code></pre></div><p>至少需要配置：</p>
<ul>
<li>上游 VPN 的 WireGuard / OpenVPN 参数；</li>
<li>WG-Easy 管理密码；</li>
<li>服务器公网地址或域名；</li>
<li>AdGuard Home 上游 DNS；</li>
<li>sing-box 绕过规则；</li>
<li>必要的服务端口和固定容器 IP。</li>
</ul>
<p>启动时使用：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-shell" data-lang="shell"><span style="display:flex;"><span>./up.sh -d
</span></span></code></pre></div><p>不要直接运行普通的 <code>docker compose up</code>，因为 runtime compose 文件和相关配置需要先由生成器创建。<code>up.sh</code> 会先运行配置生成逻辑，再启动完整 stack。</p>
<h2 id="安全注意事项">安全注意事项</h2>
<p>这类网关方案虽然方便，但也需要注意安全边界。</p>
<h3 id="1-不要使用默认密码">1. 不要使用默认密码</h3>
<p><code>config.yaml</code> 里的 WG-Easy 密码、Clash API secret、AdGuard Home 凭据都应该修改。尤其是管理界面如果暴露在公网，默认密码会非常危险。</p>
<h3 id="2-谨慎暴露管理端口">2. 谨慎暴露管理端口</h3>
<p>通常只应该公开 WireGuard UDP 端口。WG-Easy、MetaCubeXD、AdGuard Home 管理界面最好不要直接暴露在公网。</p>
<h3 id="3-确认上游-vpn-服务条款">3. 确认上游 VPN 服务条款</h3>
<p>多设备共享、网关转发、链式 VPN 是否被允许，取决于你的上游 VPN 服务条款。部署前应该自己确认。</p>
<h3 id="4-注意-dns-绕过">4. 注意 DNS 绕过</h3>
<p>本方案会限制普通 DNS 查询，但不能自动阻止所有应用层 DoH / DoT 行为。如果你需要更严格的 DNS 策略，需要额外做域名、IP、SNI 或应用层策略控制。</p>
<h2 id="总结相比旧版方案的主要变化">总结：相比旧版方案的主要变化</h2>
<p>和旧版 <code>WG-Easy + Gluetun</code> 相比，新版架构主要有这些变化：</p>
<table>
  <thead>
      <tr>
          <th>方面</th>
          <th>旧版</th>
          <th>新版</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>接入层</td>
          <td>WG-Easy</td>
          <td>WG-Easy</td>
      </tr>
      <tr>
          <td>上游 VPN</td>
          <td>Gluetun</td>
          <td>Gluetun</td>
      </tr>
      <tr>
          <td>分流能力</td>
          <td>主要依赖路由和 iptables</td>
          <td>sing-box 规则集分流</td>
      </tr>
      <tr>
          <td>DNS</td>
          <td>需要额外配置</td>
          <td>默认集成 AdGuard Home</td>
      </tr>
      <tr>
          <td>配置方式</td>
          <td>多文件手动维护</td>
          <td><code>config.yaml</code> + 模板生成</td>
      </tr>
      <tr>
          <td>规则管理</td>
          <td>粗粒度</td>
          <td>geosite / rule-set 级别</td>
      </tr>
      <tr>
          <td>可观测性</td>
          <td>主要看日志</td>
          <td>可配合 MetaCubeXD 查看 sing-box</td>
      </tr>
      <tr>
          <td>扩展能力</td>
          <td>相对有限</td>
          <td>更适合未来加入更多规则和服务</td>
      </tr>
  </tbody>
</table>
<p>所以，总结一下，旧版更简单，适合只想把所有流量送进上游 VPN 的用户。新版则更适合长期使用，尤其适合需要分流、DNS 过滤、集中管理和多场景适配的用户。</p>
]]></content:encoded></item><item><title>GpgFrontend的前世今生：我与一个开源加密工具的成长之路</title><link>https://blog.bktus.com/archives/5l9c2j/</link><pubDate>Wed, 12 Nov 2025 22:21:17 +0100</pubDate><guid>https://blog.bktus.com/archives/5l9c2j/</guid><description>&lt;h2 id="缘起遇到-gnupggpg">缘起：遇到 GnuPG（GPG）&lt;/h2>
&lt;p>我第一次接触 GPG 是在 2021 年 4 月左右。那时候我还只是一个对计算机世界充满好奇的学生，对密码学的理解也只停留在“密码就是加密字符串”这样的表层。直到我读到非对称加密的原理：一个公钥可以让所有人加密信息，但只有拥有私钥的人才能解密。这让我非常惊讶。这种“数学意义上的信任”很吸引我，它优雅、严谨，而且不可逆。我当时觉得，这种技术的美感其实并不比任何艺术作品差。所以我开始学习 GPG 命令行的各种操作，从生成密钥到签名验证，反复去试，去琢磨其中的逻辑。&lt;/p></description><content:encoded><![CDATA[<h2 id="缘起遇到-gnupggpg">缘起：遇到 GnuPG（GPG）</h2>
<p>我第一次接触 GPG 是在 2021 年 4 月左右。那时候我还只是一个对计算机世界充满好奇的学生，对密码学的理解也只停留在“密码就是加密字符串”这样的表层。直到我读到非对称加密的原理：一个公钥可以让所有人加密信息，但只有拥有私钥的人才能解密。这让我非常惊讶。这种“数学意义上的信任”很吸引我，它优雅、严谨，而且不可逆。我当时觉得，这种技术的美感其实并不比任何艺术作品差。所以我开始学习 GPG 命令行的各种操作，从生成密钥到签名验证，反复去试，去琢磨其中的逻辑。</p>
<p>但是，我也发现了一个问题：命令行的门槛实在太高了。特别是有的时候，我只是想快点做一些简单的操作，却要输入一长串命令，说实话感觉挺不爽的。对于不熟悉技术的用户来说，GPG 的命令行几乎就是一片晦涩的荒原，基本上把想尝试的人都挡在了外面。所以我开始想，如果能给 GPG 做一个简单易用的图形界面，让它像一台看得见、摸得着的“密码机”那样直观、方便，每个人都可以很简单地拥有一台耐用又小巧的“密码机”，也许就会有更多人愿意去尝试。这个想法在当时看起来微不足道，但是后来好几年的技术折腾，其实都是从它开始的。</p>
<blockquote>
<p>“密码机”让人立刻联想到某种坚固、可靠的小设备，就像早期的机械密码机（如
Enigma）那样充满仪式感。它承载的不仅是技术，更是一种对安全的信念。这种机器功能不求繁多，却必须精准可靠。用户按下一个按钮，期望它执行的动作必须**可预期且安全
**。这种对“可控性”的追求，就是“密码机”的灵魂。</p></blockquote>
<p>我开始去找现成的方案。那个时候已经有一些 GUI 工具了，比如 Kleopatra。但是它们很多界面复杂、功能太多，有的还引入了 X.509 证书体系，这在当时一下子就把我劝退了。我想要的是一个更轻、更纯粹的东西。后来我发现了一个叫 <a href="https://git.bktus.com/gpgfrontend/gpg4usb/">gpg4usb</a> 的项目，它非常接近我理想中的样子：轻量、可携带、跨平台。但是很遗憾，它早就停止更新了，只支持 GPG 1.4 版本。这就意味着它和现代系统之间的兼容性问题几乎无法回避，也没办法支持子密钥。</p>
<p>所以我开始琢磨：能不能在它的基础上重写一部分，让它重新活过来？大概在 5 月份，我花了半个月左右的时间，在宿舍里读它的源码，摸索 GPG 接口的调用方式，研究 Qt 框架和跨平台的兼容问题。这个过程比较孤独，但是非常充实。每次让一个新功能成功跑起来，心里的那种成就感都很难形容。等我终于让它在 GPG 2 的环境下运行起来，并且修掉了不少原有的 Bug 之后，我决定给这个焕然一新的项目起一个新名字：<a href="https://gpgfrontend.bktus.com/">GpgFrontend</a>，也就是 GPG 的图形前端。这也是我人生中第一个完整的开源项目。</p>
<p><img alt="GpgFrontend" loading="lazy" src="https://img.bktus.com/P7a8YV8G.webp"></p>
<h2 id="亮相从宿舍里的代码到-github">亮相：从宿舍里的代码到 GitHub</h2>
<p>把第一个版本上传到 GitHub 之后，我其实没有期待太多关注。毕竟这是一个非常小众的领域，GPG 本身就不是大众常用的东西。但是几天之后，我收到了第一个 issue。一位用户说程序在某个操作系统上没办法运行，这位用户附上了日志，还提了修改的建议。那个时候，我第一次感受到了一种力量，让我愿意继续为这个项目投入时间。</p>
<p>之后，越来越多的人开始用 GpgFrontend。他们提问题、提建议，还有人帮忙翻译。每一个反馈都让我发现，这个项目已经不只是我个人的“技术玩具”，它是一个真的有人在用的工具。从那以后，我对“开源”的理解发生了很大的变化。开源不只是把代码共享出来，它更像是一个不断有反馈、不断演化的生态。</p>
<p>在后来的两三年里，我慢慢明白，GpgFrontend 不可能，也不需要成为一个“大而全”的工具。它要做的事情很清楚：帮助用户更方便地加密、解密、签名和验证。它的价值不在于功能有多少，在于好不好用、可不可靠。到现在，我已经很明确地把它定义成一个“轻量级、安全的密码机”，就和我当初刚接触 GPG 的时候想要的一样。</p>
<p>对于熟悉命令行的老用户，它是一个节省时间的辅助工具；对于初学者，它是一座通向密码学世界的桥。所以在 UI 设计上，我尽量保持简洁，让所有核心操作一目了然；在底层实现上，我让每个操作都直接对应 GPG 原生的命令，以保证稳定和兼容。后来我发现，这种“小而专”的定位，反而成了 GpgFrontend 最大的特点。别的项目在追求更多功能的时候，我选择让它保持专注。</p>
<h2 id="演进把项目当成技术的试验田">演进：把项目当成技术的试验田</h2>
<p>随着版本一个个推进，GpgFrontend 成了我学习新技术的练兵场。我在工作和学习中学到的新东西，都会尝试放进这个项目里。比如说，我研究了 Chromium 的多线程架构，把线程调度和任务隔离的机制引入到 GpgFrontend，这样执行加密的时候界面不会再卡住，竞态和多线程常见的一些 Bug 也尽可能地减少了。然后，我为它设计了插件系统和 SDK 接口，让第三方可以在运行时动态扩展功能。我还优化了构建脚本，引入了 CI/CD，让不同平台的打包流程更自动、更可靠。另外，通过这个项目的跨平台支持，我也了解了 Windows、macOS、Linux 之间的各种实现差异，以及在不同操作系统和发布平台下打包的流程。</p>
<p>这些尝试让工具本身变得更好，也让我学到了真正的工程经验：怎么设计一个可维护的架构，怎么在稳定和创新之间平衡，怎么在不破坏旧功能的前提下重构。GpgFrontend 就这样从一个简单的实验项目，慢慢变成了一个结构比较合理、稳定可靠的开源工具。</p>
<p>在我上网络安全课的那段时间，教授讲到了数据安全和密钥管理的重要性。我突然发现，自己在项目早期的一些实现其实是有隐患的。比如说，密钥派生算法过于简单，存储缺少轮转机制，还有部分内存没有加保护。所以我开始做一次全面的安全重构。</p>
<p>在 <a href="https://github.com/saturneric/GpgFrontend/releases/tag/v2.1.9">2.1.9</a> 版本中，我加入了安全等级、启动自检、AES-GCM 加密模式、密钥轮转机制和安全内存。另外，我重新设计了程序的数据结构，让临时的机密信息在用完之后，能够尽可能安全地从内存中擦除。这些改动看起来都在“幕后”，但实际上让 GpgFrontend 的安全性和可靠性提升了不少。我一直觉得，安全并不是某一个功能，它是一种态度。只有在设计的时候就把安全考虑进去，工具才能经得起时间，才能让人一直信任。</p>
<p>维护这个项目的这些年，我慢慢感受到一种技术以外的满足感。GpgFrontend 虽然不是什么“热门项目”，但它确实帮到了一些真实的用户。有人用它验证软件包的签名，有人在工作中用它快速处理安全通信，还有人告诉我，它是自己学习 GPG 的第一扇门。我不记录用户，也不专门去汇总各个平台的下载量。说实话，我也不知道到底有多少人在用它。但是我挺喜欢这种“不知道”的，它让我觉得 GpgFrontend 是一份很纯粹的贡献。说得具体一点，它就是一台“小密码机”，随手就能拿到，可以跟着人到任何地方，在需要它的场景里默默地干活。</p>
<h2 id="展望稳定专注与长期主义">展望：稳定、专注与长期主义</h2>
<p>接下来的几年，我不会让 GpgFrontend 有很大的变化。更新会一直进行，但主要集中在使用体验、稳定性、Bug 修复和一些小的优化上。我更倾向于让它保持轻量和可控。现在的软件行业到处都在讲“快速迭代”，我反而希望它能成为一个例外，做一个稳重、可靠、值得信赖的工具。也许它永远不会流行，也不会上技术新闻的头条，但只要它能一直帮到那些真正需要它的人，我觉得就都值得了。</p>
<p>最近几年，Rust 在安全领域越来越受关注，我也一直在留意。我研究了几个用 Rust 实现的 GPG 替代库，比如 RPGP、Sequoia 等。它们在内存安全和并发管理上做得更好，也支持 OpenPGP 的一些最新特性，我认为这应该是以后的方向。但是，我也必须面对现实：Rust 的生态还不完全成熟，和现有 GPG 生态之间的兼容性也还有待验证。</p>
<p>所以，我计划以后建立一个独立的分支，用实验的方式接入 Rust 版本的加密库，并通过一个新的密钥数据库层来做封装。这种渐进式的迁移，能让我在不破坏主线稳定的前提下，看看新技术到底是不是可行。我一直认为，稳一点的更新比盲目的创新更重要。毕竟对于一个安全工具来说，它的价值不在于新，在于能不能被信任。而这种信任的积累，可能要以 10 年为单位来算。</p>
]]></content:encoded></item><item><title>二零二三年四月第二周技术周报</title><link>https://blog.bktus.com/archives/0ee6o6/</link><pubDate>Mon, 10 Nov 2025 21:38:26 +0100</pubDate><guid>https://blog.bktus.com/archives/0ee6o6/</guid><description>&lt;p>这篇周报是事后补写的。这一周，主要的工作是把配置下发服务从单地的数据中心改造成多地部署，这次主要动的是数据层和缓存层。&lt;/p>
&lt;p>我负责的配置下发服务，客户端分布在广州、深圳、上海、北京等全国多个城市。客户端需要根据运营策略拉取各种动态或静态的配置，比如节日活动、功能开关、故障时的临时屏蔽等等。这些配置由服务端统一下发，客户端根据自身的属性（地域、版本等）拉取对应的内容。随着客户端的规模越来越大，问题就出来了。特别是在活动上线、客户端批量启动的时候，配置拉取的请求会在短时间内剧增，服务端的 QPS 暴涨，严重的时候甚至会拖垮主服务节点。&lt;/p></description><content:encoded><![CDATA[<p>这篇周报是事后补写的。这一周，主要的工作是把配置下发服务从单地的数据中心改造成多地部署，这次主要动的是数据层和缓存层。</p>
<p>我负责的配置下发服务，客户端分布在广州、深圳、上海、北京等全国多个城市。客户端需要根据运营策略拉取各种动态或静态的配置，比如节日活动、功能开关、故障时的临时屏蔽等等。这些配置由服务端统一下发，客户端根据自身的属性（地域、版本等）拉取对应的内容。随着客户端的规模越来越大，问题就出来了。特别是在活动上线、客户端批量启动的时候，配置拉取的请求会在短时间内剧增，服务端的 QPS 暴涨，严重的时候甚至会拖垮主服务节点。</p>
<p>其实在容器层，我已经做了全国多地的 Kubernetes Workload 部署。但是数据层，也就是数据库和 Redis，仍然集中在广州。这样一来，即便请求是从北京或者成都的容器发出的，最终还是要跨地域访问广州的数据中心，延迟高，压力也全部集中在一个地方。另外，虽然服务里有容器内的缓存，但是容器本身应该保持无状态，它的运行内存并不适合长时间、大量地持有配置缓存。一旦配置数据涨到几百兆甚至上 GB，运维和资源的成本都会急剧上升。所以，我决定从数据层和缓存层入手，做一次更彻底的多地部署改造。</p>
<p>具体来说，主数据库实例（可读可写）仍然放在广州，运营人员在这个实例上管理和写入配置。然后在上海、北京、成都等地各部署一个只读副本，主库通过异步同步把数据分发到各地的副本，各地的容器只连接本地的副本拉取配置，不再跨地域访问。Redis 也按同样的思路，每个地域部署自己的实例，服务端优先从本地的 Redis 取配置，没有命中再回源到本地的只读副本或者主库。为了让客户端能命中就近的节点，我基于 DNS 做了地域级别的接入调度。另外，在配置下发平台里给不同的 Kubernetes Workload 打上标签（地域、版本等），容器按标签识别自己的身份，拉取对应的配置。运营人员还是在部署在广州的统一平台上集中管理配置，这一点没有变。</p>
<p>这样做的好处是，读请求分散到了各地的只读副本，主库的压力小了很多；客户端拉配置的网络路径变短了，延迟也降了下来；写入仍然集中在主库，配置管理还是统一的，操作上也简单。说白了，这个方案能成立，是因为配置下发是一个典型的“写少读多”的场景：新增活动、屏蔽功能这类写入很少，绝大多数请求都是读。</p>
<p>部署下来，效果还是比较明显的。各地客户端拉取配置的延迟明显降低，主库的读请求几乎全部转移到了只读副本上。在活动上线的流量高峰期间，整个系统表现稳定，没有再出现某个集中节点被打爆的情况。</p>
<p>最后记录几点体会。首先，多地部署数据库和缓存的时候，需要评估网络延迟、数据同步延迟和一致性的要求。对于配置下发这种场景，最终一致性就够了，不需要强同步。但是副本的同步延迟还是要监控起来，以免某个地方的配置没有及时生效。另外，缓存就近部署效果更好，尽可能不要让网络延迟拖累了 Redis。容器的无状态设计还是要坚持，缓存尽量外部化，避免容器失效导致缓存丢失或者资源浪费。还有就是，Workload 的标签管理是这个方案的核心，通过标签可以比较灵活地控制不同地域、不同版本的客户端拿到什么配置；地域的入口（DNS 或者其他导流的机制）也必须能解析到就近的入口，这样客户端才会走最近的节点。最后，权限划分要明确：主库的写权限、只读副本的只读账号、运营平台的权限，要分开。</p>
]]></content:encoded></item><item><title>关于个人对AWS服务的使用感受</title><link>https://blog.bktus.com/archives/fms9jf/</link><pubDate>Fri, 24 Nov 2023 21:07:50 +0800</pubDate><guid>https://blog.bktus.com/archives/fms9jf/</guid><description>&lt;p>从 2022 年 11 月开始，我就在用 AWS 的服务，到现在已经接近一年了，而且用的不是免费套餐。从一开始觉得新奇、陌生，到现在了解得比较深入，这期间遇到了不少事情，在这里记录一下。&lt;/p></description><content:encoded><![CDATA[<p>从 2022 年 11 月开始，我就在用 AWS 的服务，到现在已经接近一年了，而且用的不是免费套餐。从一开始觉得新奇、陌生，到现在了解得比较深入，这期间遇到了不少事情，在这里记录一下。</p>
<p>为什么会选择 AWS？因为我个人有一些服务需要找地方运行，比如博客网站（WordPress）、Git 仓库、RSS 订阅等等。当时我觉得 AWS 在云服务市场占的份额最大，它的解决方案应该已经非常成熟了。对于 AWS，我还是比较信任的，愿意花钱买合适的服务，让我这些个人托管的服务能够长期稳定地运行。其实在这之前，我也开过 AWS 的免费套餐，但是一直没有找到合适的使用场景，用了一段时间就放着了，免费套餐的周期就这样白白浪费了。</p>
<p>一开始我用的是 EC2，先试了 1 核 1G 内存的 T2.micro 实例，后来发现内存不够用，机器直接卡死。所以我换成了 1 核 2G 内存的 T2.small，又加了 SWAP 分区，每个月大概要 17 美元。虽然这个价格包括了带宽费用，但我还是觉得有些贵。然后我开始考虑 AWS 的保留实例，听说可以减少 60%~70% 的费用，看起来很划算。所以我下定决心买了三年的保留实例，先付了 170 美元，之后每个月承诺支付 4.75 美元，这样算下来每个月大约 8.84 美元，这个价格还算合理。</p>
<p>然后就踩了一个坑。当时我配置了 30G 的系统盘和 10G 的数据盘，以为 30G 的系统盘是免费的。另外，考虑到数据的安全，我还加了定期的快照备份，想着快照也花不了多少钱。结果月度账单一出来，要 20 美元。我当时很奇怪，钱都花到哪里去了？我在控制台里找，又到 Cost Explorer 里进一步查，才发现系统盘和数据盘都是按我申请的规格计费的，原来 AWS 的服务器和云硬盘是分开计算价格的。而且我当时不知道怎么选硬盘的类型，用的是第二代 SSD，性能虽然好，但我根本用不到这么高的性能，价格还比第三代 SSD 贵 20%。还有就是那几个快照，每个月的费用居然超过了 7 美元。不得不说，AWS 的费用查询界面非常复杂，一个选项下面可能有很多项目，需要一个一个取消勾选，慢慢去找到底是哪一项花了多少钱。</p>
<p>所以，从 2022 年 12 月开始，我就开始不断地削减成本。先是取消了快照备份，然后取消了数据盘，最后还想办法减小了系统盘的容量。系统盘扩容很方便，一键就可以操作，但是缩减容量就非常麻烦，需要手动操作。后来在网上找了一圈，才发现 AWS 有个叫 Lightsail 的产品，对个人用户友好很多，当时我就有点后悔了。</p>
<p>DNS 也是一样。AWS 的 DNS 托管每个域名每个月要 0.5 美元，而且还会根据 DNS 的查询次数额外计费。特别是域名里配了多个 CNAME 跳转的话，一次访问会被算成多次解析，如果不想被这样计费，就需要设置 Alias。AWS 的 DNS 功能确实很强大，但是我这种个人用户根本用不上，而且 Cloudflare 的 DNS 貌似更快，还是免费的。当时我把两个域名都迁移到了 AWS 并且托管了，DNS 这一块每个月大约要 1.5 美元。最后想了想，还是把 DNS 解析迁回了 Cloudflare。值得一提的是，AWS 的域名续费也很贵，一个 com 域名要 12 美元以上，而 Cloudflare 大约是 7 美元左右。这也是一笔支出，差不多相当于一个月的 EC2 费用，对于个人用户来说，实在不划算。</p>
<p>另外，从 2024 年 2 月开始，AWS 要对公网 IPv4 地址收费，不管是弹性 IP 还是直接绑定在 EC2 上的，算下来每个月大约要 3 美元。我觉得不划算，就决定把公网 IPv4 地址去掉，让服务器只走 IPv6。这样一来，我的网站基本上就没法直接访问了，因为很多情况下对 IPv6 的支持并不完善。我又试了 AWS CloudFront 的方案，但是发现 CloudFront 回源不支持 IPv6，也不支持内网的 IPv4 地址。思前想后，好像没有解决办法了？（实际上，可以把域名托管到 Cloudflare，然后开启代理。）</p>
<p>当然，AWS 也有它的优势。我这台 1 核（基准性能 20%）的机器能跑很多服务，响应速度也很快，一年下来也非常稳定，几乎没有出过什么问题。另外，像 CloudFront 这样的加速服务，每个月有 1TB 的免费额度，而且是永久的。所以，我把一些对速度敏感的站点都放在了 CloudFront 上，一年下来速度稳定，响应也快，只是配置有些复杂，需要一些 Web 方面的基础知识。</p>
<p>所以，作为个人用户，我不推荐用 EC2 这类产品。如果一定要用，建议选 Lightsail 这样的产品，计费比较简单，不会在不知不觉中开启各种“增值服务”，导致账单失控。如果要在 AWS 上托管，最好是比较轻量的静态网站，用 Lambda、Amplify、S3 这类按量付费的产品才是划算的。对于域名和 DNS，个人用户还是推荐 Cloudflare 这样的服务商，免费，性能也好，域名续费也不贵。我认为 AWS 的产品更适合企业这样的大型用户，他们可以和 AWS 协商价格，比我们按官网的标价买要划算得多。还有就是，需要注意 AWS 的技术支持是要额外付费的。</p>
<p>总之，AWS 提供了很多功能和选项，但是对于个人用户来说，很多功能用不上，费用也经常出乎意料。在用之前，一定要仔细了解每个选项是怎么计费的，以免产生不必要的费用。</p>
<h2 id="现状">现状</h2>
<p>目前，我已经把博客网站和 RSS 订阅这些动态网站迁移到了一家专门做网站托管的服务商，趁着最近黑色星期五的促销，以比较优惠的价格买了几年的服务。这家服务商除了托管，还提供邮件服务、缓存加速和域名注册，管理界面也比较简单。对于个人用户来说，这样的服务就够了。</p>
<p>除了博客，我还有一些个人开源项目的静态网站需要托管，为了省事，我选了 Netlify。</p>
<p>另外，我还是会用 AWS 的 EC2 来部署一些自己开发的后端程序，做开发和测试用。我在 EC2 上配置了公网 IPv6 地址，为之后用 Cloudflare 代理做准备，这样也可以避开公网 IPv4 收费的问题。</p>
<p>目前来看，我对这次迁移和托管的选择还是比较满意的，后面就看这几年运行得怎么样了。</p>
]]></content:encoded></item><item><title>知识的相对性和条件性</title><link>https://blog.bktus.com/archives/7gmavw/</link><pubDate>Wed, 09 Nov 2022 22:37:35 +0800</pubDate><guid>https://blog.bktus.com/archives/7gmavw/</guid><description>&lt;p>本文根据我 2018 年 5 月写的&lt;a href="https://blog.bktus.com/archives/0tui6f/">知行论（四）&lt;/a>重写。&lt;/p>
&lt;p>一个人所知道的东西，虽然只是这个人自己的知，但对于为人处世是有好处的。知道得越多，思考就会越深刻。但是，这种知不是一味地去接受。要知道，世界上没有绝对正确的知，没有全部清楚的知，没有绝对权威的知，也没有处于事物本来面目的知。如果有人说他掌握了真知，我认为这是不可能的。就算是神说它有真知，我也不知道它到底有没有。&lt;/p></description><content:encoded><![CDATA[<p>本文根据我 2018 年 5 月写的<a href="https://blog.bktus.com/archives/0tui6f/">知行论（四）</a>重写。</p>
<p>一个人所知道的东西，虽然只是这个人自己的知，但对于为人处世是有好处的。知道得越多，思考就会越深刻。但是，这种知不是一味地去接受。要知道，世界上没有绝对正确的知，没有全部清楚的知，没有绝对权威的知，也没有处于事物本来面目的知。如果有人说他掌握了真知，我认为这是不可能的。就算是神说它有真知，我也不知道它到底有没有。</p>
<p>如果一味地接受外来的知，这些知就是死的。所谓死的知，就是没有经过“析”这个过程的知，也就是说，我没有用我已有的知识去分析它，把它转化成我自己的东西。这样的知不是我的知，我没办法灵活地运用它，只是知道而已。没办法运用，自然也就没办法拿来思考。而且，一味接受外来知识的话，我也没有能力把它们全都分析一遍。所以我不这样做。能够分析，能够有所领悟，对我来说是一件快乐的事。先知道，再分析，再思考，这是我理解的“知”的道理。</p>
<p>行也是一样。一件事情做成功了，如果就此认为这个方法是通用的、绝对的，那就错了。成功的方法，是根据当时的所知、所思产生的。在成功的路上，有很多变数是我所不知道的。变数没有变，方法就是行得通的；变数一旦变了，方法就行不通了，行也就不能成功。所以说，没有一成不变的知，也没有一成不变的方法。</p>
<p>另外，我按照一个方法去做，让事物发生了改变。但是我能感知到的，只是我感知得到的那部分变化。简单的变化可以感知，复杂的变化是很难感知的。所以，行要谨慎，不要骄傲。骄傲的人用一个方法，是不会变通的；谨慎的人能够应对各种变化，因为他会把自己全部的所知、所思都用上。不谨慎的人只看到事物的表面，就武断地下判断，这样是会有所损失的。所以，我认为谨慎地去行，不轻率，才是成功的方法。</p>
]]></content:encoded></item><item><title>浅论专注于目标并尝试实现它</title><link>https://blog.bktus.com/archives/dv99w5/</link><pubDate>Wed, 09 Nov 2022 22:36:08 +0800</pubDate><guid>https://blog.bktus.com/archives/dv99w5/</guid><description>&lt;p>本文根据我 2018 年 5 月写的&lt;a href="https://blog.bktus.com/archives/er6eer/">知行论（三）&lt;/a>重写。&lt;/p>
&lt;p>行的过程中，我们一定是有目标的。但是，很多时候，越是迫切地想达到一个目标，越是不容易达到。迫切地想要达到，心里就会渴求，这样就静不下来。静不下来就会浮躁，浮躁就会漏掉很多东西。这个时候，我们所知道的是片面的，所思考的也是不周全的。&lt;/p></description><content:encoded><![CDATA[<p>本文根据我 2018 年 5 月写的<a href="https://blog.bktus.com/archives/er6eer/">知行论（三）</a>重写。</p>
<p>行的过程中，我们一定是有目标的。但是，很多时候，越是迫切地想达到一个目标，越是不容易达到。迫切地想要达到，心里就会渴求，这样就静不下来。静不下来就会浮躁，浮躁就会漏掉很多东西。这个时候，我们所知道的是片面的，所思考的也是不周全的。</p>
<p>所以，我认为行的方法，是处在一种“不求”的状态，但心里清楚地知道有这个目标。心思不全放在目标上，知的范围就可以宽很多，做事情也能像平常一样，这样才有可能成功。</p>
<p>另外，行的过程中要用心。用心，就必然要专心，心不专一是达不到目标的。心不专一的话，我所知道的、所思考的，都不能全部发挥出来。那怎么才能专心？我的体会是，做事之前一定要有所知，有所思，让这些思考产生出一套做法。有所知，还没开始做的时候，心就能专一；有所思，有了做法再去做，心就能定下来。如果没有思考，也就没有做法，心就会乱。</p>
<p>所以，专心说白了就是能把心神聚在一起，心里没有杂念，没有其他的事情。心神如果是散开的，心就是乱的。专心的人做事的时候才能顺畅，才可能成功。</p>
]]></content:encoded></item><item><title>知与行并不是合二为一的</title><link>https://blog.bktus.com/archives/8zkrzg/</link><pubDate>Wed, 09 Nov 2022 22:35:03 +0800</pubDate><guid>https://blog.bktus.com/archives/8zkrzg/</guid><description>&lt;p>本文根据我 2018 年 5 月写的&lt;a href="https://blog.bktus.com/archives/9h5dq9/">知行论（二）&lt;/a>重写。&lt;/p>
&lt;p>这一篇说“行”。很多时候，我们认为自己获得了知，就能够去行，而且认为行了就一定会成功。但其实，行是很难做到的。事物的变化很难预料，这些变化并不是我们可以预先知道的，所以行必须谨慎，用来防范这些预料不到的变化。事物的变数多，这是行难的原因之一。&lt;/p></description><content:encoded><![CDATA[<p>本文根据我 2018 年 5 月写的<a href="https://blog.bktus.com/archives/9h5dq9/">知行论（二）</a>重写。</p>
<p>这一篇说“行”。很多时候，我们认为自己获得了知，就能够去行，而且认为行了就一定会成功。但其实，行是很难做到的。事物的变化很难预料，这些变化并不是我们可以预先知道的，所以行必须谨慎，用来防范这些预料不到的变化。事物的变数多，这是行难的原因之一。</p>
<p>我认为，知和行并不是合二为一的。我们知道了某个规律、某个方法，就想着去用它。但是，这些规律和方法所适用的情况，其实都是我们自己构想出来的。我们能举出的例子，能想到的细节，都来源于我们自己的思考，而我们的思考难免会有荒谬的地方、不周全的地方。如果就这样去行，一旦遇到没有想到的细节，我们就会慌；一旦出现没有想到的情况，行就会停下来。所以，要时常去行，这才是成功的方法。怎么行？先知，然后行。怎么知？行了之后，自然就知道了。</p>
<p>另外，在行的过程中，一定会有别的声音来阻止我。有人会说我的做法哪里错了，有人会说我的认识哪里错了。这个时候，如果我全都听从了，就此停下，是不可能成功的。如果我一点都听不进去，一意孤行，也很难成功。那该怎么办？我的想法是，别人所说的、所知道的，也都是基于他们自己的感知、思考和行动形成的。没有所谓的绝对真知，也没有所谓的权威之知，更没有什么永恒不变的知。所以，对于这些意见，我会去看它们表面上说的是什么，再揣测它们背后的本意。虽然没办法完全理解它们本来的意思，但一定会有所收获。</p>
<p>所以，对于别人的意见，不妨先听一听，想一想，然后用行动去检验。如果确实有用，就拿来用，但不是盲从。如果没用，就坚持自己的见解。在行的时候，也要时常回过头去想一想。行有了成功的结果，那么对我来说它就是成功的，虽然这个方法不一定适用于所有情况。所以，我的行能不能成功，是不能凭借别人说的话来预测的。</p>
]]></content:encoded></item><item><title>论什么是事物本质</title><link>https://blog.bktus.com/archives/219pfm/</link><pubDate>Wed, 09 Nov 2022 22:33:17 +0800</pubDate><guid>https://blog.bktus.com/archives/219pfm/</guid><description>&lt;p>本文根据我 2018 年 5 月写的&lt;a href="https://blog.bktus.com/archives/y8d47o/">知行论（一）&lt;/a>重写。&lt;/p>
&lt;p>写下这些文字，其实是出于偶然。那段时间由于一些原因，我比较浮躁，而写这些东西能让我静下心来。我把这些想法叫做知行论，它来源于我的生活、我读过的书，还有我自己的思考。对我来说，这些想法集合成一套理论之后，既像一件武器，也像一副防具，能帮我扛住生活上的一些挑战。这一篇先说“知”。&lt;/p></description><content:encoded><![CDATA[<p>本文根据我 2018 年 5 月写的<a href="https://blog.bktus.com/archives/y8d47o/">知行论（一）</a>重写。</p>
<p>写下这些文字，其实是出于偶然。那段时间由于一些原因，我比较浮躁，而写这些东西能让我静下心来。我把这些想法叫做知行论，它来源于我的生活、我读过的书，还有我自己的思考。对我来说，这些想法集合成一套理论之后，既像一件武器，也像一副防具，能帮我扛住生活上的一些挑战。这一篇先说“知”。</p>
<p>对于一件事物，我们一般是怎么去认识它的？用眼睛看它，用耳朵听它的声音，用手去摸它、感受它，这样我们就认为自己感知了这个事物。然后再用脑子去想，用心去体会，我们就认为自己了解了它。但是，我们看到的、听到的、摸到的，都只是我们的感官能够感觉到的那一部分。感官感觉到的东西是什么样子，取决于感官本身的构造。那么，能不能存在一套构造完全不同的感官，它感觉到的事物和我们感觉到的完全不一样？我认为这是可能的。如果是这样，那就说明我们没有办法通过感官知道事物本来的样子。</p>
<p>感官靠不住，那思考呢？其实思考也有它的问题。我们的头脑与心思是被外界塑造出来的，而且我们想事情的时候，总是带着自己的愿望。比如说，身体受到伤害，我们会难过；身体得到了什么，我们也会高兴。我们的心思寄托在身体上，想事情自然会从自己的利害出发。另外，我们的知识也大多来自别人。我们生下来是一张白纸，老师教给我们知识，而老师的知识又是老师的老师教给他的。所以，我们脑子里的东西，很多其实是别人的想法，通过一代一代的教授传到了我这里。</p>
<p>所以，不管是感知还是思考，都是从我们自己的角度出发的。我以前常常以为，想得越深入，就越接近事物的本质，但其实并不是这样。我所思考的，说白了就是把事物通过我的感官读进脑子里，然后按照我的方式加工一遍。这样得到的认识，并不是事物本身。也就是说，事物的本源是不能被准确感知的，事物的真理也是不能被准确思考的。这就是“知”的局限性。</p>
]]></content:encoded></item><item><title>论心理上的一种“反质变”现象</title><link>https://blog.bktus.com/archives/jiuc9z/</link><pubDate>Wed, 09 Nov 2022 22:25:09 +0800</pubDate><guid>https://blog.bktus.com/archives/jiuc9z/</guid><description>&lt;p>本文根据我 2017 年 5 月写的&lt;a href="https://blog.bktus.com/archives/rr970y/">反质变的直接促成&lt;/a>重写。&lt;/p>
&lt;p>一般来说，我们都认同量变是质变的必要准备。但是我发现，在一些特定的情况下，量变积累到一定程度，会因为一个突发事件而导致一种反方向的质变，我把它叫做“反质变”。这种反质变威力很大，来得很快，而且几乎是不可逆转的。量变积累得越深，反质变来得越猛烈。&lt;/p></description><content:encoded><![CDATA[<p>本文根据我 2017 年 5 月写的<a href="https://blog.bktus.com/archives/rr970y/">反质变的直接促成</a>重写。</p>
<p>一般来说，我们都认同量变是质变的必要准备。但是我发现，在一些特定的情况下，量变积累到一定程度，会因为一个突发事件而导致一种反方向的质变，我把它叫做“反质变”。这种反质变威力很大，来得很快，而且几乎是不可逆转的。量变积累得越深，反质变来得越猛烈。</p>
<p>突发事件只是表面上的原因。其实，真正的原因在于，量变在大量积累的过程中，自己对于其中的具体信息并没有真正把握。这个时候突发事件一触发，就会产生怀疑，最后导致反质变的发生。反质变发生之后，在别人看来，我的外在表现可能并没有什么改变，但是我对这件事情的看法已经发生了根本的改变。这种改变对思想的冲击是非常大的，在短时间内对身心也会造成很大的冲击。之后，虽然量变还可能继续积累，但是反质变对思想造成的改变已经无法挽回了。</p>
<p>举个例子，比如我认为一个人是可以相信的，所以我觉得不用去详细了解这个人的具体想法。现实中他的表现也一次次印证了我的直觉，然后我继续相信这个人，信任也逐渐加深。这样，我对这个人的信任就像操作一个黑盒子一样，不用了解内部是怎么运作的，也知道这个人是可以信任的。这样的信任程度很深，但也是极其敏感的。一旦发生了一次失信的事件，不管这个人是不是真的失信，也不管事情有多小，只要从我的角度看，我单方面判断这很有可能是失信的表现，反质变就发生了。</p>
<p>这个时候，这个人的行为首先冲击的是我的身心，让我直接产生了被欺骗的感觉。然后，我对这个人的看法会发生根本的改变，虽然表面上我仍然对他微笑。之后这个人的表现是不是还值得信任，对这个反质变来说作用是微乎其微的。当我还想重新相信这个人的时候，这个反质变就会形成一种很强的阻力。</p>
<p>所以，当收到别人毫无猜疑的信任的时候，要珍惜。因为这种信任是很深的，也是极其敏感的。虽然自己觉得自己的行为在道理上是可以理解的，但是对于对方来说并不一定是这样。一旦发生了突发事件，这段信任就会发生不可逆转的转变。我认为，这个过程对于其他相同或者相似的情况，也是成立的。</p>
]]></content:encoded></item><item><title>TransRepair: Automatic Testing and Improvement of Machine Translation（机器翻译的自动化测试和改进）</title><link>https://blog.bktus.com/archives/f6adzy/</link><pubDate>Thu, 30 Sep 2021 16:38:59 +0800</pubDate><guid>https://blog.bktus.com/archives/f6adzy/</guid><description>&lt;p>我之前阅读了 TransRepair: Automatic Testing and Improvement of Machine Translation 这篇论文。这篇论文提出了一种叫做 TransRepair 的方法，从软件测试的角度去自动测试机器翻译模型。下面我将从几个方面介绍我对其中内容的理解。&lt;/p></description><content:encoded><![CDATA[<p>我之前阅读了 TransRepair: Automatic Testing and Improvement of Machine Translation 这篇论文。这篇论文提出了一种叫做 TransRepair 的方法，从软件测试的角度去自动测试机器翻译模型。下面我将从几个方面介绍我对其中内容的理解。</p>
<h2 id="transrepair-简介">TransRepair 简介</h2>
<p>TransRepair 是一种自动检测和修复机器翻译软件一致性问题的方法，它提供了黑盒和灰盒两种方式来解决这个问题。它的主要步骤包括生成测试用例、建立测试准则，以及自动修复。论文给出的测试用例生成算法比较清晰、严谨，也比较详细，对于句子之间的差异，用了四种量化方法来比较。另外，TransRepair 把结构一致性作为断言，实验的设计也比较全面，结果也比较丰富。</p>
<h2 id="关键问题的理解">关键问题的理解</h2>
<ol>
<li>一致性问题，指的是机器翻译软件在处理一组语义和结构都相似、只在某些特定词语上略有不同的句子时，对应的翻译结果里，某一句或者几句的某些部分出现了语义或者结构上的不一致。</li>
<li>TransRepair 生成测试用例的方法，是对输入的原句做词语替换，形成一组突变句。为了做到这一点，它用词向量模型来计算词语之间的关联性。选出候选词以后，还会把候选词带回句子里做成分分析，确认句子的语义和语法没有发生太大的变化。</li>
<li>在验证测试用例输出的句子对是否一致时，TransRepair 首先用 Widiff 对字符串的成分做差异比较。为了让相似度的量化更可靠，它还把原句和译句中涉及差异的成分做部分删除，构造出一个集合，计算集合里每个元素之间的相似度，取最大值。论文里用了四种不同的方法来量化相似度，其中有一部分和之前的 SIT 方法有相似之处。</li>
<li>论文的实验设计比较有特点。它先提出问题，讨论解决的方法，然后围绕这四个问题设计实验，并给出相应形式的实验数据。实验从准确度、有效性、修复能力以及和人工方式的对比等多个角度，论证了这个方法是有效的。实验数据的呈现也比较直观，容易看懂。</li>
<li>在阈值的处理上，TransRepair 和 SIT 不一样。它通过机器小步遍历运算，得到统计上最优的阈值，再用人工辅助和统计分析的方式做一致性判别，我认为这样设定阈值的逻辑更有说服力。而 SIT 的阈值大多靠经验设定，说服力和可操作性都比较低。</li>
<li>TransRepair 的自动修复分为黑盒和灰盒两种方式。黑盒对应的是 Google Translate，由于这个软件没有开源，对输入输出的相关参数了解有限，所以只能对输入和输出本身进行操作。灰盒对应的是 Transformer，它的源码和训练集都可以拿到，所以可以把握输出结果的可能性，并在训练集和模型结构上做修复。</li>
<li>TransRepair 的优势在于可以自动检测和修复一致性问题。这个方法准确度高，可行性和可复现性也好，我认为这和它准确的实施方法，以及对现有方法缺陷的考虑和补充有很大关系。但是，这个方法的效率比较低，而且只对一致性问题有效。</li>
</ol>
<p>所以，总结一下，这篇论文提出的 TransRepair 是一种有效的自动测试和改进机器翻译软件的方法，特别是针对一致性问题。论文把这个方法解释得很详细，也给出了实验证据和比较分析。</p>
]]></content:encoded></item><item><title>对一段挫折进行反思</title><link>https://blog.bktus.com/archives/lb5b92/</link><pubDate>Fri, 12 May 2017 21:02:06 +0800</pubDate><guid>https://blog.bktus.com/archives/lb5b92/</guid><description>&lt;p>在现实生活中，我总会遇到各种各样的挑战和难题。刚碰到的时候，我经常会感到吃惊，不知道该怎么办。等冷静下来，对问题进行分析之后，我一般会在现有的体系和框架里面去找解决的办法。对于一些常规的问题，这样做可能是有效的。但是有的时候，问题的根源恰恰就在这个体系本身。我以前常常想通过加强现有的体系去解决问题，但是这样做效果一般都很有限，有时候根本解决不了问题，最后只会越陷越深，没办法摆脱困境。&lt;/p></description><content:encoded><![CDATA[<p>在现实生活中，我总会遇到各种各样的挑战和难题。刚碰到的时候，我经常会感到吃惊，不知道该怎么办。等冷静下来，对问题进行分析之后，我一般会在现有的体系和框架里面去找解决的办法。对于一些常规的问题，这样做可能是有效的。但是有的时候，问题的根源恰恰就在这个体系本身。我以前常常想通过加强现有的体系去解决问题，但是这样做效果一般都很有限，有时候根本解决不了问题，最后只会越陷越深，没办法摆脱困境。</p>
<p>我在学习上就是这样。以前我从来没有真正怀疑过自己所用的学习模式。直到一次比较严重的挫折之后，我才开始想，这可能就是我成绩出问题的根源。问题越来越严重，我发现自己遇到了以前从来没有遇到过的挑战。一开始我很迷茫，觉得一切都很荒谬。试了一些方法之后，我发现只是加强原来的学习模式，并不能带来明显的改善。到最后，我几乎不知道该怎么办了。</p>
<p>但是问题还在那里，我必须找到解决它的方法。所以在最近的一次挫折之后，我决定去挑战自己的学习模式。我仔细分析了自己的问题，发现根源并不只是粗心或者运气不好。其实，是我缺乏勇气去面对更深层的基础问题。我一直相信自己的智力没有问题，但是从小学到初中，我的基础问题已经暴露过很多次了，只是我一直没有重视。初中的时候，我的信息学老师就提醒过我，说我在数学上的粗心，可能是基础不牢的表现。那是我第一次听到这样的说法，但是当时我没有放在心上，因为我还没有能力去深入分析问题。</p>
<p>上了高中以后，这个问题变得更加明显，我在基础知识上的缺陷完全暴露了出来。高中的考试对基础知识的要求更高，只靠智力已经掩盖不住基础问题的严重性了。那么，基础到底包括哪些方面？我认为，它包括解决问题时思路的严谨性、操作的准确性，还有对基础知识的掌握程度。现在我可以坦白地说，我的基础知识确实存在严重的问题，这是我以前一直不敢面对的。比如说，在科学计数法、单位换算、基本物理单位的概念、数学的除法运算这些方面，我都有明显的不足。以前做题的时候，我经常忽视细节，比如这个量能不能取零、有没有意义等等。特别是对于基础知识和概念，我从来没有重视过，还有点轻视。我错误地认为这些知识在具体的问题里用处不大，但现在我才明白，这是一个很严重的误解。</p>
<p>所以，我发现自己的学习方法是有问题的：分析问题不够细，也不够深。遇到问题的时候，我没有从根本上去分析，也很少去想问题背后的原因。对问题的分析，不能只是表面上处理一下，要找到背后更深的原因，并且对自己的现状进行批判性的思考。另外，遇到挫折的时候，也要有一定的心理承受能力，从里面吸取经验教训。</p>
<p>这次学习上的缺失提醒了我，必须从根本上解决问题，回到基础知识的学习上。忽视基础知识和概念是错误的。只有真正理解和掌握了基础知识和概念，才能更好地解决问题，才能有进步。我希望通过这样的方式，以后在学习和生活中都能更好地面对挑战。</p>
]]></content:encoded></item></channel></rss>