<?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>安全 on Tech Philosopher</title><link>https://blog.bktus.com/tags/%E5%AE%89%E5%85%A8/</link><description>Recent content in 安全 on Tech Philosopher</description><generator>Hugo</generator><language>zh-CN</language><lastBuildDate>Thu, 19 Nov 2026 23:11:24 +0100</lastBuildDate><atom:link href="https://blog.bktus.com/tags/%E5%AE%89%E5%85%A8/index.xml" rel="self" type="application/rss+xml"/><item><title>二零二三年四月第三周至五月第二周技术周报</title><link>https://blog.bktus.com/archives/p4m6jn/</link><pubDate>Thu, 19 Nov 2026 23:11:24 +0100</pubDate><guid>https://blog.bktus.com/archives/p4m6jn/</guid><description>&lt;p>上一篇技术周报，&lt;a href="https://blog.bktus.com/archives/0ee6o6/">二零二三年四月第二周技术周报&lt;/a>，是 2025 年 11 月补写的，之后就停了很久。原因其实很简单，一个是打字很麻烦，写文章的时候这里改改那里改改，改着改着句子就坏掉了，脑子里是一个句子，写出来又是另外一个句子，有些词或者介词根本就看不到了。另外一个是之前有两篇用了 AI 辅助，但是效果并不好，一看就是 AI 写的，不像是我写的，也不像是我说的话。&lt;/p></description><content:encoded><![CDATA[<p>上一篇技术周报，<a href="https://blog.bktus.com/archives/0ee6o6/">二零二三年四月第二周技术周报</a>，是 2025 年 11 月补写的，之后就停了很久。原因其实很简单，一个是打字很麻烦，写文章的时候这里改改那里改改，改着改着句子就坏掉了，脑子里是一个句子，写出来又是另外一个句子，有些词或者介词根本就看不到了。另外一个是之前有两篇用了 AI 辅助，但是效果并不好，一看就是 AI 写的，不像是我写的，也不像是我说的话。</p>
<p>这些技术周报，其实是我当时每一周真正发给领导的周报。但是我并不会把每一条都写进文章里，一个是出于保密，虽然我已经离职了，但是把详细的服务名称之类的直接说出来并不是很好。所以从第一篇开始，我都是看着当时那一周的周报，想一想哪些事情比较重要，再挑出这些事情和当时的想法，写成一篇文章。</p>
<p>现在我终于找到了一个比较好的方法：边看周报边口述，提到什么就说什么，回忆一下当时那一周自己的感觉，然后再整理成文章，具体是怎么整理的，可以看 <a href="https://blog.bktus.com/ai-policy/">AI 使用说明</a>。这样一来，周报就不再一周一篇了，而是几周合成一篇。文章虽然长一点，但是能记下来的东西反而多了很多。</p>
<p>如果你对后台开发在一线到底是什么样子感兴趣，这个系列写的就是当时每一周真实发生的事情：一个流量很大的账号系统，合规的需求怎么落地，许可证的模型怎么设计，接口怎么加固，Redis 缩容又踩了什么坑。除了当时是怎么做的，我也会说说现在回头看，我会怎么想。</p>
<h2 id="四月第三周">四月第三周</h2>
<h3 id="合规需求只做软注销">合规需求：只做软注销</h3>
<p>这一周主要是各种杂事，其中最多的是合规相关的需求。当时应该是国内刚引入相关的法律法规，要求做两件事情：一个是用户可以注销账号，另外一个是注册的时候要永久记录用户的 IP 地址。这两件事情本身都没什么复杂的，注销账号要更复杂一些，需要结合当时的数据库模式、用到的技术栈，还有账号的数据是怎么存的，分散在哪些地方，再来看怎么做注销，而且要让它对现有体系的改动比较小。</p>
<p>最后做的是一种软注销，并不是真正地把账号删掉了，而是在数据库里软删除，其他地方分散的那些数据也不会再被任何微服务引用，那么我们就认为这个账号已经注销了，死了。为什么没有直接删除呢？主要是因为很麻烦。当时公司内部的存储结构，主要是缓存后面再挂数据库，但问题其实不在数据库，而在业务逻辑。很多很老的业务逻辑，几十个微服务，这里用到了账号的 ID，那里又用到了和 ID 相关的某些字段。如果我们把数据删掉了，某个我们不知道的地方还引用着它，发现数据库里找不到了，就会报错，很可能让这个微服务不稳定，或者直接退出，影响到其他的用户。账号属于特别核心的服务，用户流量又比较大，不能中断。一旦中断超过 15 秒，下游的客户也在监控我们，马上投诉就来了。所以只能用软注销。</p>
<h3 id="记录-ip-地址一个想当然的审计服务">记录 IP 地址：一个想当然的审计服务</h3>
<p>记录 IP 地址这件事情，本来也很简单。我们维护了一个比较中心的 Elasticsearch（ES）实例，里面有从开始到现在所有注册相关的记录，只要在这里面加个字段就好了。但是在这之前，我做了一件现在看来有些想当然的事情。当时刚做微服务，我觉得账号很难做审计：一个账号什么时候注册，什么时候登录，什么时候注销，这些记录都分布在不同的微服务里。所以我提议写一个账号审计相关的微服务，平时用到账号的那些微服务，都把事件异步上报到这个审计服务，由它整理以后再写到 ES 里，而不是东写一个西写一个。</p>
<p>这个想法虽然非常理想，但是我现在感觉没有什么必要做。很多时候你做完以后，发现它很鸡肋：统一的异步上报，再做一些合并分析写到 ES，听起来很好，但实际上你很少会用到这些分析出来的东西。主要的业务都不是从这种地方挖掘数据的，它的作用主要是方便我们 debug，追查线上问题，而这并不需要这么多加工。所以按照我现在的想法，是不会去做这个事情的。但当时既然已经有了这个审计服务，记录注册 IP 的时候，我就直接放到了它上面：注册的时候在埋点里带上 IP，跟原来上报的东西一块异步上报到审计服务，再由审计服务写到 ES，绕了一圈，最后还是像原来那样写进了 ES。我不知道他们现在怎么样了，我怀疑这个审计服务大概率会被后面接手的人干掉。也有可能后面接手的人比较老成，不会去动它，以免那些不清楚的上下文带来不稳定的因素，那他就要替它背锅了。</p>
<h3 id="错误码规范化">错误码规范化</h3>
<p>还有一件事情是错误码的规范化。上个团队留下来的这些微服务，需要和下游客户在云端的账号进行绑定，通过云对云，也就是 B2B 的方式通信。这方面我们其实是有规范和文档的，但是上个团队好像并不是特别在乎，只求能够顺利地和客户对接上，对接完以后出了问题，就靠研发手动去看代码，找到问题点。当时我们团队为了节省人力，决定把这些错误码整理出来，并且规范化：什么时候会报什么错误码，是什么原因，该怎么排查，全部梳理清楚写到文档里。写完以后，就可以把文档发给前面跟客户对接的那些同学（借用一下“同学”这个说法，比较前沿一些），让他们直接跟客户说是什么原因，不要再来烦我们研发了。这些错误码当时应该是我来找的，周报里并没有提到团队中其他同学做这一步。找完以后我再和产品对齐，达成一致，写到 Wiki 里。后面正式的文档就不是我来写了，是团队里其他同学根据我写的 Wiki，整理成规范化的文档，再按照产品的流程发给客户。</p>
<h3 id="新的账号模型从按人头收费到许可证">新的账号模型：从按人头收费到许可证</h3>
<p>这一周最主要的事情，是一个新的账号模型。当时有一个新的客户，要求比较高，需要我们调整和加强原来的账号流程。原来关联账号的流程大概是这样的：客户的终端用户使用客户的产品，产品激活的时候会用到我们的服务，注册我们的账号，然后我们通过云对云的通知告诉客户，你的哪些终端用户用了我们的服务，再根据这个来收费。但是原来的对账方式，我只能说比较软性，不是非常严谨：我们这边导出一份报表，客户那边根据他们终端用户的情况，加上云对云的通知，也导出一份报表，两边再进行对账。收费模型也是按人头来收，你用了就算，并没有考虑用户是不是还在使用，是不是有许可证，许可证有多长，还有客户的合同到期以后，用户是不是还能继续通过我们的账号系统，获得我们提供的那些服务的权限。</p>
<p>所以我们需要一个更加严格的模型，把合同考虑进来，还有客户的终端用户用的是哪个产品。比如说，这个用户只能用两年，两年后他要付一笔钱，才能继续用我们的服务，这笔钱由客户向他们的终端用户收取。每当终端用户激活了产品，用到了我们的账号，我们都必须告诉客户：签发了什么许可证，签发了多久，有效时长是多少。这些统统都需要规范。这个模型由领导推动，他的想法是，既然现在这个客户的要求比较高，需要这样的模型，那我们就把它做成标准化的东西，以后跟新的客户也用这一套。</p>
<p>这个模型是在跟客户谈判的过程中逐渐清晰的。领导告诉我客户是怎么想的，我们该怎么做，有哪些约束，哪些必须要做，哪些不能做。然后我根据这些去建模，设计该怎么抽象，许可证该怎么做，合同该怎么做，写成文档，交给客户，也交给领导和领导的领导审查。大家一致同意以后，我再把它付诸实现：过一遍现有的微服务架构，看哪些地方需要调整逻辑，然后新起了一个许可证服务。这个许可证服务在现有账号的基础上负责新的模型，包括计价，许可证和合同的下发、激活与管理，还有一些测试用的许可证需要白名单管理，就是这些乱七八糟的事情。</p>
<h3 id="许可证不可变牌照决定能不能签发">许可证不可变，牌照决定能不能签发</h3>
<p>这个模型可以稍微说一下。首先，许可证是一个对象，或者说是一个领域对象（domain object）。我给它加了一个约束：许可证一旦创建，就不能再修改。如果需要修改，那么只能吊销现有的许可证，再签发一个新的。为什么要这样做呢？我当时主要考虑的是审计。一旦运营的操作，或者某个代码的 bug，在我们不知情的情况下调整了许可证，很多时候如果不仔细去调查，是没办法注意到的。而吊销和新签发许可证是另外一个粒度的事情，它们都会记录到前面说的那个 ES 里，什么时候都能查得到。所以系统里没有提供任何接口，能够修改一个许可证的时长、对象、有效期或者它的效果，只能吊销。</p>
<p>许可证上面还有一层，是客户的许可证，它和合同的时长有关系，我先称之为“牌照”（当时文档里应该不叫这个名字，具体叫什么我已经不记得了）。签发许可证的时候，我们需要先找到客户的牌照，再根据牌照是否到期，属于哪个客户的哪个产品，允许签发多长时间的许可证，来决定能签发哪些许可证。如果找不到任何牌照，就说明这个客户对于这个产品没有签任何合同，或者没有续约，那么就拒绝签发新的许可证。也就是说，牌照就是签发许可证的能力。</p>
<p>对于合同，我是这么抽象的：合同期间，我们给客户和客户的终端用户提供服务。合同过期以后，现有的终端用户如果许可证还没有到期，那么我们必须让他继续用，等到他的许可证到期了，才不让他用。合同到期只是意味着，我们不再接受新的用户，已经到期的用户也不能再激活他的服务，不能再激活我们的账号。</p>
<p>有了这两层抽象以后，发现确实可以灵活地表达客户的所有要求，还有我们自己的要求。合同快到期的时候，也方便我们去谈判。即使合同已经到期，续约也谈成了，但是由于流程的问题还没走完，我们也可以先发一个临时牌照给客户，让签发不要中断，让已经过期的用户还能继续付钱，继续用我们的服务。感觉挺好。后来这些都实现了，包括许可证快到期的时候需要提醒，由我们通知客户，再由客户去提醒他们的终端用户。这些消息的结构，有哪些字段，有哪些内容，还有牌照之类的术语，也是我设计好写在文档里的。</p>
<h3 id="上线以后">上线以后</h3>
<p>这个服务在我离职前上线，并且正式激活了。后面的事情我就不知道了，这个服务现在怎么样，有没有 bug。肯定是有 bug 的，我一直都在想这个事情：我以前写的代码，现在用 AI 一扫，肯定能扫出很多 bug。但是当时能跑，没有出问题，那就是好的。至于一些极端情况下才会出现的问题，只要问题不大，没有出现失误，那也就这样了。有 bug，这就是 human slop，是没有办法避免的，人写代码不可能像 AI 一样考虑得面面俱到。</p>
<p>另外，这一周还有各种治理相关的服务，跟进得比较多，就不一一说了。</p>
<h2 id="四月第四周">四月第四周</h2>
<h3 id="接口加固为什么不用公钥签名">接口加固：为什么不用公钥签名</h3>
<p>这一周比较重要的事情，是升级客户端访问账号服务的接口。这个不是前面说的 B2B 通信，而是我们自己的客户端访问账号的接口。原来这个接口比较弱，鉴权也比较弱，没有进行各种验证。很多时候我们担心，有假的客户端绕过我们一般的鉴权，非法使用我们的服务。我当时是账号这一块的主要负责人，比较重要的事项肯定交给我，所以由我来升级这个接口，并且让客户端都切换到新的接口上。新的接口会多做很多事情：需要签名，很多字段必须填写，并且要进行验证。签名依赖一个秘密，只有客户端知道，其他人不知道，我们再根据这个秘密进行签名和验证。</p>
<p>但是我们并没有使用公钥进行签名，用的是一种基于哈希算法的签名。主要是考虑到我们的客户端杂七杂八，跑在不同的终端产品上，有老的平台，也有新的平台，老的平台不一定支持验签之类 PKI 相关的东西，而且它很复杂。当时的想法是，越复杂的东西，如果没有特别的必要，不能带来什么收入，没有了它也不会出现很大的损失，那么就不做，做了也没用，反而会在实际的各种杂七杂八的环境里出现各种各样的问题。环境变量太多了，这个说 CPU 不行，那个又说没有这个库，这个库一调用就失败。等客户端一发版，改都改不了，直接就用不了了。终端用户不会考虑你这些什么安全不安全，一看用不了，马上投诉就来了，我们又不能直接给他们更新，这样损失就很大，对于客户，对于终端用户都不好。</p>
<h3 id="现在回头看">现在回头看</h3>
<p>回头看，我当时还是比较稚嫩的。我现在在大学里读研究生，多修了一些知识，特别是修了密码学或者网络安全相关的课程以后，如果现在再来做，有些设计我会多考虑考虑。该怎么设计这个协议，其实是有很多现成的最佳实践（best practice）的，以这个为宗旨来做就好。从 1970 年代到现在，安全协议是怎么变的，从每一次的教训中学到了什么新的、更好的模式，根据这些理论知识，我的设计可能会更好一点。</p>
<p>但其实，这并没有什么用。在实际的业务流程中，尽快上线，保证稳定，不出现用户用不了的情况，这才是最根本的。接口加固是附带的，做好了，也只是被薅羊毛的情况少了一些，体现不了太多成本的下降，除非是公司有要求，或者出现了比较大的安全漏洞。</p>
<h3 id="字段只能加不能减">字段只能加，不能减</h3>
<p>另外一个是协议相关的，要在客户端和 API 之间补上一个字段。这件事情我能说的主要是：字段只能加，不能减。你一旦把字段减了，你不知道原来的客户端逻辑在少了一个字段以后会出现什么情况。按理说大部分客户端应该要考虑到这种情况，但鬼知道它有没有考虑到，它有可能少了一个字段就直接报错，或者直接退出，都有可能。加字段也需要谨慎，需要了解清楚，需要测试，而且旧的客户端是用不了这个新字段的。所以，一切都要以终端用户使用产品的体验为准，而不是炫什么技术。主要是要考虑到各种兼容性，你的老服务、老客户端还在用，它们又更新不了，那它们应该怎么办。</p>
<p>还有就是接口滥用情况的监控，这一周让我设计方案，也是和接口加固相关的，主要是担心我们现在这个接口被灰产滥用。</p>
<h2 id="四月第五周">四月第五周</h2>
<p>这一周的事情还是原来的那些事情，主要是加了一些新的事项。周报里很多事项每周都会写上推进的百分比，比如说接口滥用的事项，上一周还在调查，这一周有了思路，基本上在做相关的开发，还有写文档。</p>
<h3 id="从单可用区到多可用区">从单可用区到多可用区</h3>
<p>另外一个是服务治理相关的。账号的业务当时部署在云上，上一周已经有相关的事项了：存储层是在单个可用区部署的，比如说在广州，或者在深圳。一旦单个可用区出现网线被挖断这种情况，就会出问题。当时真的出现过一次网线被挖断，整个可用区降级了，导致我们服务的延迟上升。延迟一上升，端上就会超时，客户的投诉会直接到我们这里。我们不能说是云服务商出了什么事情，虽然可以推一部分锅，但锅还是会到我们头上。所以单可用区的部署是有风险的，需要调整到多可用区部署，而且要仔细地调整。当时正在出方案，梳理哪些服务在哪些可用区，哪些服务是单可用区，哪些是一半单可用区一半多可用区，它们用到的数据库是什么状态，是云上的分布式数据库，还是 Redis，Redis 又是什么情况。</p>
<h2 id="五月第二周">五月第二周</h2>
<p>五月第一周是五一假期，放了一周，所以接着就是第二周。这一周主要是需求相关的开发，也就是上一周的那些事项，没有什么新的。</p>
<h3 id="redis-防重放缩容-20-的教训">Redis 防重放：缩容 20% 的教训</h3>
<p>新的是五一前后发现的问题。我们的网关服务用 Redis 进行防重放，具体的算法不便透露。由于流量巨大，这个 Redis 用的是比较大的容量。五一以后，为了降本，我把它缩减了 20%，觉得它平时都不会到 80%，应该没什么问题。不过这都是后话了，后来不知道什么时候，真的见鬼了，它又飙到了 100%。然后 Redis 要驱逐这些键，导致延迟飙升，网关发生了剧烈的波动，又发生了告警。我当时就后悔，为什么要缩减这 20%，因为你永远不知道它什么时候会达到你所认为的那条线上。</p>
<p>至于为什么要这么大的 Redis，是因为这个协议我们没法改变。很多老客户端必须用这个算法，而这个算法又很占 Redis 的空间，只能搞一个特别巨大的 Redis，确保防重放正常工作。最早的那一代服务，设计中并没有考虑到防重放，字段中也没有相应的东西，产品和客户端都已经发出去了，没法更新，也没法加这些字段，那就只能承受这个成本了。</p>
<h3 id="不是技术问题是组织问题">不是技术问题，是组织问题</h3>
<p>这也是一个矛盾点。刚开始做的时候，很难考虑到后面会有这么大的流量，这个业务能不能行，你当时也不知道，先上线了再说，先抢时间，抢节奏。后面你一看，当时真的没有考虑到这些事情。其实按道理来说，我现在想一想，还是能够逐步迁移到新的算法上的。但是这样很慢，也不好推动，涉及多个团队、多个客户端，需要比较大的能量。很多时候这不是技术问题，是组织相关的问题：你有没有那么大的能量把这个事情抛出来讨论，它是不是真的需要投入这么多人力去做。要不然，把这个 Redis 扩容一倍，可能都比拉这些人讨论、实现、测试要便宜。</p>
<h3 id="两个-java-服务的超时">两个 Java 服务的超时</h3>
<p>另外，就是以前<a href="https://blog.bktus.com/archives/kwvjou/">提到过</a>的两个 Java 服务，可能框架写得不好，总会有各种各样的超时问题。当时我还是本科生，没有读研，用了好多网上能找到的监控手段，看是 JVM 的问题，还是框架本身写得不好，但是也看不出什么来，可能是火候不到。一直到 2023 年 5 月，这两个服务还是有问题。虽然当时找到了一些端倪，也做了一些优化，做了一些线程膨胀相关的事情，但是框架很难改。它主要是用 Spring Boot 魔改的，这里魔改一下，那里魔改一下，鬼知道改了哪里，然后改的人又离职了，留下这些乱七八糟的东西，只能一个一个去分析。</p>
<p>当时我还是懵懵懂懂的。现在看我做了那么多事情，好像技术了得，但实际上理论知识还是欠缺的，对于性能分析，对于整个计算机体系结构，CPU、三级缓存、内存到底是怎么样的，包括汇编方面，根本没有实际的认识，还是一团迷雾。这团迷雾，要到我现在读研究生的时候，才慢慢散开。具体的分析，后面的周报里应该也会有一些事项体现，这里先不说了。</p>
<h2 id="最后">最后</h2>
<p>这几周就先说这么多，五月第三周的事情后面再慢慢说，想到哪说到哪，这样思路也不会断，文章也不会太长。这样口述下来，感觉比我自己打字要好多了，也能说出一些打字打不出来的东西：打字的时候就会忘掉的想法，当时的一些细节，或者是觉得麻烦不想打出来，后面就慢慢忘掉的事情。现在我的记忆力还不错，还记得住，后面就慢慢把这些周报补上，至少写到 2024 年离职的时候，这样以后就不会再忘记了，对以后的自己也是一笔宝贵的财富。</p>
]]></content:encoded></item><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>个人 VPS 自部署的长期主义：干净与安全</title><link>https://blog.bktus.com/archives/6upskf/</link><pubDate>Fri, 02 Jan 2026 23:20:27 +0100</pubDate><guid>https://blog.bktus.com/archives/6upskf/</guid><description>&lt;p>我开始认真折腾个人 self-host，大概已经有五六年了。严格意义上开始管理我自己的 VPS
的时间点，应该还可以往前追溯。最初的动机其实很简单：有些服务我每天都在用，比如密码管理器、音乐播放、笔记同步、个人网站、代码仓库等等。既然如此，为什么不干脆自己部署？这样一来数据在自己手里，也不用被各种平台订阅和涨价牵着走。&lt;/p></description><content:encoded><![CDATA[<p>我开始认真折腾个人 self-host，大概已经有五六年了。严格意义上开始管理我自己的 VPS
的时间点，应该还可以往前追溯。最初的动机其实很简单：有些服务我每天都在用，比如密码管理器、音乐播放、笔记同步、个人网站、代码仓库等等。既然如此，为什么不干脆自己部署？这样一来数据在自己手里，也不用被各种平台订阅和涨价牵着走。</p>
<p>这几年一路走下来，说实话，self-host 并不省心。我要维护系统、备份数据、关心安全、偶尔还要救火。但它给我的回报也很明确：</p>
<ul>
<li>数据完全掌控在自己手里</li>
<li>不再被订阅价格牵着走</li>
<li>对系统、网络和安全的理解明显更深</li>
</ul>
<p>现在我一台服务器跑着十几个服务，成本只是一台服务器的钱。在这两年取消了不少第三方平台的订阅后，算下来，整体成本可能反而更低。对我来说，这种“复杂但可控”的状态，反而比依赖一堆外部服务更安心。当然不这适合所有人，我感觉有：有一定技术背景的人、喜欢折腾的人以及愿意为稳定与掌控付出时间的人，这三者合一就适合这样。</p>
<p>到现在，我并不觉得自己成了什么“专家”，但有到现在两件事的感受越来越强烈：<strong>安全性<strong>以及</strong>服务器环境的整洁程度</strong>，这也是这篇文章的两个主线。这两个问题，几乎决定了你这台服务器上的各类服务能不能长期稳定地用下去。然后就是需要迁移的时候，比如换了一个更便宜或者更好的 VPS 供应商，这个时候的工作量（我自己就换了好几次，知道真的换不动了才稳定下来）。</p>
<h2 id="草莽阶段">草莽阶段</h2>
<p>最开始的时候，我的做法非常朴素。我会直接在宿主机上安装服务，然后安装 Nginx 或者
Apache2（httpd）。比如用 Nginx 做反向代理，Nginx 这类 Web 服务器 的好处是配置文件可以拆开，每个站点一份，用域名来区分各个服务而不是端口号，看起来井井有条。那时候我觉得这套方案挺优雅的。</p>
<p>但随着服务慢慢变多，问题开始一点点浮现。有的服务需要特定版本的依赖，我很难在同一个环境安装不同版本的各种依赖库或者数据库。而有的会在系统里留下各种临时文件；配置文件散落在 <code>/etc</code>、数据放在 <code>/srv</code>，日志又在 <code>/var</code>。一开始你还能记得“这是哪个服务的”，时间一长就完全混在一起了。</p>
<p>这期间，当我想删除一个不用的服务时，我已经不敢确定自己删得干不干净。特别是有的服务提供“一键安装脚本”，安装的时候一时畅快，等到了你想摆脱它的时候，你会发现当初的脚本不知道做了什么改动，如何复原都毫无头绪。你很难确认还有没有残留的配置、后台进程，甚至不知道删错东西会不会影响别的服务。这种不确定感，本身就是一个风险，对于强迫症来说，每每想起简直是如鲠在喉。</p>
<h2 id="容器化阶段">容器化阶段</h2>
<p>后来我把几乎所有服务都迁移到了 Docker 里。而且，到现在越来越倾向于将所有能用的到的服务或者工具软件容器化，再去部署。有些不提供标准的容器化部署方案的，但又很想用的服务，我会直接自己进行容器化包装，形成自己的容器化的解决方案。</p>
<p>真正改变体验的不是 Docker 本身，而是 <strong>Docker Compose</strong>。容器这东西，本质上就不应该被当成“长期维护对象”，它随时都可以被删掉、重建，你需要意识到这个。早期的时候，我觉得 Docker Compose 配置文件麻烦，为什么不用命令直接创建一个容器，然后让这个容器长期运行。后来等我要更新，或者这个服务依赖多个底层的其他容器的时候，问题就逐渐浮现出来。如果当初将对服务的部署写下来，写到一个配置文件中，然后每次就执行这个配置文件就能完美复现原先的部署，不需要自己额外配置什么 Bridge 网络，或者什么
hostname，亦或者是重启策略。这个节省了大量的时间和精力，并且配置的时候出错的可能性，也大大降低了。</p>
<p>到现在，我能够总结出：真正需要被长期维护的，只有三样东西：</p>
<ul>
<li>服务配置（包括版本，网络，存储等）</li>
<li>数据（主要是 Volumes 和其他映射的目录）</li>
<li>部署配置（Docker Compose 的各类 Yml 配置文件）</li>
</ul>
<p>不管是重装系统，还是换一台机器，只要这三者还在，这些服务就能在这个新的地方完美地克隆。而且，宿主机本身终于变得“干净”了。各个目录下不再到处是你几年之前装过、现在已经忘记用途的东西。所以，在这个阶段，我单独创建了一个 git 仓库来收集和管理所有我用到的服务的对应的 Docker Compose 配置文件，一年下来，我感觉这样是经得起各类场景的考验的。</p>
<h2 id="一个服务一个数据库">一个服务一个数据库</h2>
<p>这个是一个值得一提的点。很长一段时间里，我的所有服务共用一个数据库实例。这在逻辑上看起来非常合理：资源省、结构简单、管理集中。但真正长期维护下来，你会发现这其实是一个<strong>非常不友好的设计</strong>。</p>
<p>每多一个服务，就多一套用户、权限、密码；想迁移一个服务，就得小心翼翼地把数据库剥离出来；数据库版本一旦升级，所有服务都要跟着承担风险。对于不熟悉某个数据库的人来说，管理权限和用户是一件头疼的东西，你需要通过命令行或者什么数据库管理软件，仔细地区分和妥善保管各个服务的用户以及他们的密码。</p>
<p>后来我干脆反过来做了一件事：**每个服务，单独一个数据库实例。**也就是，每个
Docker Compose 中独立地会有一个数据库的 service。长期观察下来，对个人 self-host
来说，这并没有想象中那么“浪费”。一个数据库容器通常只占一两百兆内存，在一台 4c8g
的 VPS，甚至 2c4g， 或家用服务器上，是可以容忍的。</p>
<p>但换来的好处是非常实在的：服务之间彻底隔离，大大提高了安全性，然后后续也不用再为权限和兼容性焦头烂额。直接一件将所有数据和配置打包带走即可，每个数据库就只有这个对应服务的数据。</p>
<h2 id="最小暴露面原则">最小暴露面原则</h2>
<p>早期我几乎把所有服务都直接暴露在公网，用反向代理加登录验证来保护：</p>
<ul>
<li>一个 Nginx Proxy Manager</li>
<li>所有服务都有公网域名</li>
<li>靠应用层用户名/密码防护</li>
</ul>
<p>当时我也觉得：“所有服务都设置有用户名和密码，应该没问题吧？”，后来我慢慢才意识到，这就是自己骗自己。只要其中<strong>一个服务</strong>出现：暴力破解漏洞、认证绕过或者
RCE（远程代码执行），攻击者就可能拿到容器权限甚至宿主机权限。最初的是我遇到的情况是，我非容器部署的 gitlab 服务，在 gitlab 有次出现严重的远程执行漏洞后，我没有及时知道这件事。然后某一天，我发现服务器就被注入了木马，这还是 Cloud Provider 提醒我我才知道的。如果那个时候我的服务器上存着照片、视频、备份数据，后果会是灾难性的。</p>
<p>另外不同服务的安全成熟度差异巨大，技术栈五花八门；有些项目还很年轻，对安全的考虑远不成熟；我也不可能每天盯着各类安全公告。一旦其中某一个服务出现漏洞，或者这些服务用得框架或者依赖，比如最近的 React 技术栈相关的安全漏洞，那这个或者这些服务就可能在短时间内爆雷。如果这个时候容器化以及隔离做的不好，攻击者拿到的不一定只是那个服务，而很可能是整台机器。然后就是隐藏的木马脚本，或者挖矿脚本。</p>
<p>这也是我后来形成的一个核心原则：能不对公网开放的服务，就不要对公网开放。博客、静态页面这种，被攻击了损失也有限；但笔记、密码管理器、管理后台这种东西，一旦出事就是灾难。所以，需要好好评估自己现在对外暴露的服务。以我个人的经验来看，最能够让人放心的就是各类静态网站，或者只是通过参数生成页面没有数据库的。但是，很多服务我都想用，如何做到有些暴露有些不暴露？因此，我现在的实践是只对公网暴露真正需要的服务，比如静态博客、极少数公共服务。Git 仓库尽量不对外或只暴露只读静态视图（通过
gitweb 或者 cgit 暴露），而动态服务、管理后台、笔记、密码管理器等一律不直接暴露在公网。</p>
<h3 id="部署私有-vpn">部署私有 VPN</h3>
<p>在后来，我发现解决这个问题的关键，是 VPN。我在服务器上部署了一个私有的 VPN（比如
WireGuard），把所有私有服务全部放到<strong>只在内网可访问的网络里</strong>。只有当我连接
VPN，拿到一个虚拟内网 IP 后，然后以这个内网 IP 为起点，才能访问这些服务。整体思路是：</p>
<ul>
<li>VPN 提供一个虚拟私有网段（如 <code>10.8.x.x</code>）</li>
<li>Docker 内部服务使用另一个私有网段（如 <code>172.x.x.x</code>）</li>
<li>两个网段通过路由互通</li>
<li>公网无法直接访问这些服务</li>
</ul>
<p>这一步的意义在于：我不再需要为每个服务单独设计“防御方案”，因为它们根本就不在攻击面上。再配合一个只在内网工作的反向代理和 DNS，使用体验反而比公网还好：域名清晰、服务稳定，而且非常安心。</p>
<h3 id="内部反代与域名解析">内部反代与域名解析</h3>
<p>进一步优化体验，我在内网部署一个 内部 Nginx 容器（在 172.24.0.0/16 下），和对外提供服务的 Nginx 实例（比如 172.20.0.0/16）完全隔离开来。这个内部 Nginx 实例固定绑定到私有 IP（比如 172.24.0.2），只服务通过 VPN 网络连接进来的流量。</p>
<pre class="mermaid">
  flowchart LR
  %% Clients
  PUB[&#34;Public Internet User&#34;] --&gt;|&#34;HTTPS&#34;| PNGX[&#34;Public Nginx (*.example.com)&#34;]
  PNGX --&gt; PBLOG[&#34;Public Service (e.g., blog/static)&#34;]

  %% VPN access
  DEV[&#34;Your Device\n(WireGuard Client)&#34;] --&gt;|&#34;VPN Tunnel&#34;| WG[&#34;WireGuard Server (10.8.0.0/24)&#34;]

  %% Internal name + reverse proxy (VPN-only)
  WG --&gt;|&#34;DNS&#34;| DNS[&#34;Internal DNS (172.24.0.4)&#34;]
  WG --&gt;|&#34;HTTPS&#34;| INGX[&#34;Internal Nginx (172.24.0.2)&#34;]

  %% Private services
  subgraph DOCKER[&#34;Docker Private Networks&#34;]
    INGX --&gt; VAULT[&#34;Vaultwarden&#34;]
    INGX --&gt; NOTES[&#34;Notes / Joplin&#34;]
    INGX --&gt; GIT[&#34;Git Service&#34;]
  end
</pre>
<p>然后，再加一个强制的内部 DNS 服务，所有通过 VPN 进来的流量都只能够使用这个 DNS
提供的域名解析服务。实际的成熟的部署方案有很多，比如 AdguardHome 等，这还能够同时解决广告拦截、域名劫持问题。这个 DNS 服务除了解析通过的普通的网络流量外，还专门代理*.vpn.example.com 下的所有 DNS 解析，比如：</p>
<ul>
<li><code>git.vpn.example.com</code></li>
<li><code>notes.vpn.example.com</code></li>
<li><code>vault.vpn.example.com</code></li>
</ul>
<p>这些 DNS 都统一解析到内部的 Nginx 的监听的 IP，172.24.0.2。这样在 VPN 已连接的情况下，后续通过浏览器直接输入对应的域名，就能够直接访问对应的内部服务。所有流量都在内网完成。这个域名，最好是要在自己名下，然后在外部 DNS 管理中，*.vpn.example.com 设置为 NXDOMAIN 或者 VPS 的 IP 地址，来确保如果不小心没有通过 VPN 来访问内部服务，流量不会被意外转发到其他地方去。</p>
<h3 id="隔离数据库容器">隔离数据库容器</h3>
<p>数据库不应该和其他无关服务在同一个 Docker 网络里。为此我又做了一件事：让每个服务、数据库单独一个 isolated bridge，在这个 bridge 下只有这两个容器能互相通信且该
bridge 不连接外部网络。也就是说，一个服务即便被攻破，它能接触到的，也只有自己的数据库，而不是整台服务器上所有的数据库。比如这样：</p>
<pre tabindex="0"><code>services:
  db:
    image: postgres:16-alpine
    ...
    networks:
      - iso
    restart: unless-stopped

  joplin:
    image: git.stdv.de/saturneric/joplin:latest
    ...
    depends_on:
      - db
    networks:
      - iso
      - vpn
    restart: unless-stopped
networks:
  iso:
    internal: true
  vpn:
    external: true
</code></pre><p>可以看到，db 只在 iso 网络中和 joplin 一对一通信，这个网络阻止该在网络内直接访问外部网络（internal: true）。这样其他服务的被入侵后，一般无法通过网络的方式来访问到我的 joplin 的数据库。但这并不是“绝对安全”，前提始终是攻击者没有拿到宿主机权限。但在现实世界里，<strong>减少横向移动的可能性</strong>，本身就是非常重要的一层防护。</p>
<p>这样做其实也可以防止 hostname / database 名冲突，就是很多在同一个网络下的
database 公用同一个 hostname，那么很可能会导致有的时候某些服务访问错了数据库。</p>
<h2 id="防火墙策略">防火墙策略</h2>
<p>如果你使用的是 VPS，我的建议是：优先使用 Cloud Provider 提供的防火墙，而尽量减少宿主机防火墙规则。然后对于外部防火墙，尽可能地严格限制入方向的放行的端口，服务都通过域名和反代来访问。原因包括：双重防火墙极易混乱，你很容易忘记配置了哪一个，哪一个没有配置；然后，我也发现 Docker 端口映射有时会绕过本地防火墙，这个可能引起意外的内部服务端口暴露，很多时候自己并没有发现。然后，云防火墙能提前挡掉大规模扫描流量，这个也是将这个计算消耗转移到 Cloud Provider 身上。</p>
<p>一般来说云防火墙入方向只放行下面的这些端口：</p>
<ul>
<li>80 / 443</li>
<li>VPN 端口</li>
<li>SSH</li>
<li>其他你认为真的有必要开的端口</li>
</ul>
<p>其他端口即便在宿主机监听，只要云防火墙不放行，对外就是不可见的。你只能够通过 VPN
来访问到这些端口，这个就省心多了。</p>
<h2 id="ssh-安全">SSH 安全</h2>
<p>这个领域有很多其他的优秀的文章，我就一些很基础但非常重要的点，这些也是我现在一直在做的：</p>
<ul>
<li>禁止 root 用户 SSH 登录。如果需要使用到 root 用户，则使用普通用户 + sudo</li>
<li>普通用户的 SSH 用户名不要太容易猜测，比如 admin 什么的。</li>
<li>普通用户设置长随机口令（建议密码管理器生成），而平时默认用<strong>密钥登录</strong>。</li>
<li>可选：只允许普通用户使用密钥登录，禁用密码。（要小心密钥没有备份然后设备丢失的情况）</li>
</ul>
<p>很多人会建议更换 SSH 的端口号，有关于个人环境下是否更换 SSH 端口，下面是个人的观点：</p>
<ul>
<li>个人环境下安全收益有限</li>
<li>后续某些配置复杂度会上升</li>
<li>最终还是视个人习惯决定</li>
</ul>
<h2 id="后记">后记</h2>
<p>我现在其实上了 Dedicated Server，而不再是 VPS，也就是类似在机房租了一台看得见的物理服务器。因为我现在其实需要托管几十个容器（捋了一遍都是我要的）。这可能也是这个 Self-Host 确实已经成为了自己每天离不开的技术基础设施的一种体现，也是说明，我认为我每个月的投入更多的资金确实有其价值。</p>
<p>然后，需要指出的是，在某些地方，文章中提到的，通过私有 VPN 来一体化支持自己的内部服务流量和普通上网的流量，很难做到。比如在这些地方，服务器的上行带宽非常贵或者用的是流量计费。这个时候，我的建议是在自己家里的软路由中，提前进行分流，将对于
Self-Host 的流量先分离出来，然后正常的上网流量就走家庭带宽出去。</p>
<p>还有就是，如果你能做到有足够的服务器的上行带宽支撑私有 VPN，很多时候你可能并不想自己的 VPS 的 IP 来浏览网页，这无疑直接暴露了你的身份。更好的情况是，你将流量引入另一个 VPN Provider 的 VPN 服务器，然后再通过它提供的出口 IP 出来。对于这个问题，我有一个长期自用的成熟的解决方案，你可以参考我的我博客文章：<a href="https://blog.bktus.com/archives/ozzkto/">搭建个人链式
VPN 网络：高效隐私保护、设备无限制管理与远程访问</a>。</p>
]]></content:encoded></item><item><title>二零二三年三月第四周技术周报</title><link>https://blog.bktus.com/archives/0b0nkf/</link><pubDate>Mon, 15 Apr 2024 22:04:06 +0200</pubDate><guid>https://blog.bktus.com/archives/0b0nkf/</guid><description>&lt;p>本周有个插入的事项，就是说我们目前在使用某云服务商的 API，对于其中的 API 鉴权，
那边有更安全的方案。原先，我们应用调取云产品的功能时，是通过一个 AccessKey 和
AccessSecret 来的。在调用的时候，需要在 SDK 中提供这两个值，然后就可以在应用中使用 SDK 提供的云产品 API 了。原先的安全要求是不能在代码中存储这两个值，公司会有某种自动扫描机制，通过这个机制可以检测代码仓库中的敏感信息，这两个鉴权用的字段也当然囊括在内。所以，我们一般都会把这两个值写在配置文件中，安全性会更好一些，也方便更改。&lt;/p></description><content:encoded><![CDATA[<p>本周有个插入的事项，就是说我们目前在使用某云服务商的 API，对于其中的 API 鉴权，
那边有更安全的方案。原先，我们应用调取云产品的功能时，是通过一个 AccessKey 和
AccessSecret 来的。在调用的时候，需要在 SDK 中提供这两个值，然后就可以在应用中使用 SDK 提供的云产品 API 了。原先的安全要求是不能在代码中存储这两个值，公司会有某种自动扫描机制，通过这个机制可以检测代码仓库中的敏感信息，这两个鉴权用的字段也当然囊括在内。所以，我们一般都会把这两个值写在配置文件中，安全性会更好一些，也方便更改。</p>
<p>而现在他们说这两个值是静态的，无法在泄露的情况下快速进行更换。毕竟我们服务一般都有几十上百个容器，而目前来说，启动配置虽然已经集中于各种配置中心里了，但是在技术上是无法实现秒级别的动态更改的，必须在修改配置后重新启动容器。而容器的启动是无法通过一次性重启所有容器来完成，必须进行分批重启以保证服务的平稳，没有十几分钟甚至几十分钟是搞不定的。</p>
<p>所以云提供商的技术团队提出了一个新的方案，通过向我们提供一些必要的而且泄露后不容易造成直接影响的凭据（好像是一个密钥文件），然后通过在线认证的机制下发动态的验证信息。这个过程比我上文提到的验证机制复杂许多，特别是我们需要在容器中纳入这样一个配置文件，或者直接在 JAR 包中纳入。然后我们需要引入一个 SDK，来专门做这个动态验证信息的获取，然后将这个信息通过某种方式传递给云产品的 SDK，最后才能实现云产品
API 的调用。</p>
<p>这个具体的过程并不是我来跟进，我把这些问题交给其他同事了，由他们来具体执行。我只是作为云账号权限的控制者，为他们提供密钥文件并给他们提供正确的方向即可。</p>
]]></content:encoded></item></channel></rss>