<?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/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:media="http://search.yahoo.com/mrss/">
  <channel>
    <title>Software Modernisation · 仁才德</title>
    <link>https://jared.lynskey.co.nz/zh-cn/tags/software-modernisation/</link>
    <description>关于软件工程与研发团队领导力的短文——绩效评估、招聘与团队扩张、CI/CD、DevOps 监控、智能体 AI。写于首尔。</description>
    <generator>Hugo</generator>
    <language>zh-CN</language>
    <copyright>© 2026 仁才德</copyright>
    <lastBuildDate>Sat, 21 Nov 2026 00:00:00 +1300</lastBuildDate>
    <atom:link href="https://jared.lynskey.co.nz/zh-cn/tags/software-modernisation/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>用 Kimi 做逆向工程，用 Claude 做现代化改造：从 Python 到 Rust</title>
      <link>https://jared.lynskey.co.nz/zh-cn/posts/2026/kimi-claude-python-rust-modernization/</link>
      <guid isPermaLink="true">https://jared.lynskey.co.nz/zh-cn/posts/2026/kimi-claude-python-rust-modernization/</guid>
      <pubDate>Sat, 21 Nov 2026 00:00:00 +1300</pubDate>
      <dc:creator>Jared Lynskey</dc:creator>
      <category>Kimi</category>
      <category>Claude Code</category>
      <category>AI Agents</category>
      <category>Reverse Engineering</category>
      <category>Rust</category>
      <category>Python</category>
      <category>Software Modernisation</category>
      <description>我怎样用 Kimi 弄清私有的 localhost 协议并用 Python 验证，再用 Claude 在不改变行为的前提下改写成 Rust，以及用基准字节和请求语料守住兼容性。</description>
      <content:encoded><![CDATA[<p>韩国有些银行网站，至今还要求你的电脑上运行着几个专有的安全程序。页面并不通过互联网和它们通信，而是调用固定的 localhost 端口，索要设备信息、安装状态、每个请求的戳记，以及一份加密的设备日志。在这些程序不再支持你用的操作系统之前，这套做法都没问题。</p>
<p>我想要的是一个小而好维护的兼容服务：能应答这些调用，又不附带任何别人的二进制文件、证书或私钥。最后做出来的是一个 Rust 程序，只监听 <code>127.0.0.1</code>，按银行页面期望的方式收发请求和响应。我在 macOS 和 Linux 上用它。Windows 版本在 CI 里通过了同样的测试，但我还没有在真正的 Windows 机器上拿它对着银行页面试过。</p>
<p>我用了两个 AI 工具，各做一件事。Kimi 帮我弄清协议，并在真实网站上验证 Python 实现。Claude 帮我把这份能跑的 Python 变成 Rust 程序。两个工具谁也替代不了谁，也都替代不了测试。逆向工程产出的是一份规范，改写必须守住它。</p>

<h2 class="relative group">先定规矩
    <div id="先定规矩" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e5%85%88%e5%ae%9a%e8%a7%84%e7%9f%a9" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>这是在我自己机器上做的互操作性项目，不是要绕过银行的管控。这个程序守着下面几条规矩：</p>
<ul>
<li>不包含专有的可执行文件，不包含抓取来的私钥，也不包含厂商的证书。</li>
<li>它上报的设备信息都是当前机器的真实信息，每个请求都生成新的值。</li>
<li>所有服务都只待在回环地址上。本地证书颁发机构（CA）每个用户一个，只能给回环用的名字签名。</li>
<li>没实现的操作一律拒绝，不返回看上去像成功的占位响应。</li>
<li>什么能被接受，由银行的服务器说了算。我本地能解密的载荷只算单元测试，证明不了兼容。</li>
</ul>
<p>这些规矩让项目更安全，也更简单。我从来不需要让服务器接受任意数据。我需要的是一个足够正确的客户端，让服务器在正常流程里接受真实的数据。</p>

<h2 class="relative group">用 Kimi 画出协议地图
    <div id="用-kimi-画出协议地图" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e7%94%a8-kimi-%e7%94%bb%e5%87%ba%e5%8d%8f%e8%ae%ae%e5%9c%b0%e5%9b%be" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>动手写替代品之前，我得先知道浏览器到底在做什么。</p>
<p>Kimi 读了登录页面和其中的 JavaScript，追踪了发往 localhost 的请求，并把调用按角色归了类。一个程序负责交易戳记，另一个收集设备和网络信息，其余的报告安装状态、键盘保护是否可用，或者环境扫描的结果。有些调用走 HTTPS 上的 JSONP，有些走 WebSocket。端口号和响应的形状都不能动，因为银行的 JavaScript 已经依赖它们了。</p>
<p>这个阶段的产出是一张协议地图，比一大堆抓下来的流量有用得多：</p>
<table>
	<thead>
			<tr>
					<th>角色</th>
					<th>页面期望它提供什么</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>戳记</td>
					<td>握手、每个请求的戳记、证书设置，以及加密的设备日志</td>
			</tr>
			<tr>
					<td>采集器</td>
					<td>设备和网络信息，走 HTTPS 和 WebSocket</td>
			</tr>
			<tr>
					<td>管理器</td>
					<td>必需的程序装了哪些，以及各自的版本</td>
			</tr>
			<tr>
					<td>键盘和键盘保护</td>
					<td>版本、健康检查和保活的应答</td>
			</tr>
			<tr>
					<td>扫描器</td>
					<td>环境扫描的应答</td>
			</tr>
	</tbody>
</table>
<p>每个操作我都记下了请求参数、响应的外层格式、内容类型、回调行为，以及失败时是什么样子。然后把每条观察结果压缩成一个小的纯函数：这里是加盐的编码，那里是一层加密，另一处是一组顺序固定的设备字段。</p>
<p>把协议规定的事实和实现上可以选择的东西分开，后来帮了大忙。端口号和字段名由协议定死。Python 的模块、Rust 的 crate 和错误类型，则由我来选。</p>

<h2 class="relative group">把 Python 当作可执行的规范
    <div id="把-python-当作可执行的规范" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e6%8a%8a-python-%e5%bd%93%e4%bd%9c%e5%8f%af%e6%89%a7%e8%a1%8c%e7%9a%84%e8%a7%84%e8%8c%83" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>Python 很适合做第一门语言。加密库用起来方便，处理字节很快，改完响应马上就能回到银行页面再试一次。所以第一个能跑的版本并不是用完就扔的 mock，它把我当时弄清楚的一切都装进了一个可以运行的形式里。</p>
<p>每条协议规则都配了一个用合成输入的本地测试。以某家银行的加密设备日志为例，测试会生成一次性的密钥和证书，运行编码器，再把结果解密，检查字段顺序和取值。这样抓出了不少编码错误，而且完全不用碰真实账户。</p>
<p>后来有一次失败说明了，光在本地通过是不够的。</p>

<h3 class="relative group">只在本地正确的请求 ID
    <div id="只在本地正确的请求-id" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e5%8f%aa%e5%9c%a8%e6%9c%ac%e5%9c%b0%e6%ad%a3%e7%a1%ae%e7%9a%84%e8%af%b7%e6%b1%82-id" aria-label="锚点">#</a>
    </span>
    
</h3>
<p>日志响应看上去没问题，测试里也能正确解密，但银行以安全程序校验错误拒绝了它。Kimi 没有继续消耗登录次数，而是重新取了两份 localhost 响应来对比：一份来自银行官方安装的程序，一份来自我的 Python 实现。</p>
<p>两边的外层格式一样，加密后的密钥形状也一样。不一样的是请求 ID。官方程序先用会话密钥把 ID 加密，然后才编码。我的实现加密了设备日志，却只对 ID 做了编码。</p>
<p>证据这么清楚，修起来就是个小改动。回归测试现在会用生成的密钥解密请求 ID，就像它原本对日志做的那样。下一次真实尝试时，银行不再返回校验错误，而是继续去核对账号和密码。再后来的一次尝试完成了登录。</p>
<p>我希望智能体做逆向工程时走的就是这个循环：观察，提出一个精确的假设，只改一处，在本地测试，然后才做一次端到端的验证。这比一口气要它给出十个猜测性的修复走得远得多。</p>

<h2 class="relative group">和 Claude 一起，从观察结果到 Rust 设计
    <div id="和-claude-一起从观察结果到-rust-设计" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e5%92%8c-claude-%e4%b8%80%e8%b5%b7%e4%bb%8e%e8%a7%82%e5%af%9f%e7%bb%93%e6%9e%9c%e5%88%b0-rust-%e8%ae%be%e8%ae%a1" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>Python 跑通之后，工作的性质变了，我也跟着换了工具。Claude 没有什么需要发现的。它的任务是在改进结构和打包方式的同时，让行为保持原样。</p>
<p>Rust 代码沿着协议本身的边界拆分：每个角色一个模块，一个模块负责读取机器真实的操作系统和网络信息，一个负责加密和本地证书颁发机构，还有一个负责命令行。异步服务器和 TLS 交给 Tokio、Hyper 和 Rustls。显式的结果类型让格式错误的证书、错误的参数和不支持的操作都按预期失败。依赖由锁文件固定，构建发布版本用的编译器由工具链文件固定。</p>
<p>Rust 还让每个操作系统都只有一个原生可执行文件，谁也不需要 Python 运行时或 PyInstaller 打出来的包。那些包原本就是最脆弱的一环。Intel Mac 的构建启动不了，原因是 cryptography 这个包不再提供 Intel 的 wheel，pip 只好从源码编译，结果链接到的 OpenSSL 和 PyInstaller 打进包里的不是同一个。对于本来就用 Python 的人，有一个很小的 PyO3 包把同一个 Rust 程序暴露成模块和命令，协议逻辑不会有第二份。</p>
<p>这里的“现代化”指什么，我得说实话。这不是由基准测试驱动的改写，我也不会宣称没测量过的提速。目标是更小的产物、并发和错误的归属更清楚、可复现的原生构建，以及少背一些打包的负担。探索阶段用 Python 是对的。要发布和维护，对我来说 Rust 更省事。</p>

<h2 class="relative group">契约：实现是新的，行为是旧的
    <div id="契约实现是新的行为是旧的" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e5%a5%91%e7%ba%a6%e5%ae%9e%e7%8e%b0%e6%98%af%e6%96%b0%e7%9a%84%e8%a1%8c%e4%b8%ba%e6%98%af%e6%97%a7%e7%9a%84" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>只有说得清什么不能变，改写才算安全。我在三个层面上做了检查。</p>
<figure class="diagram">
  <div role="img" aria-label="示意图：自上而下四个阶段。观察银行页面本来就期望的厂商程序，得到在真实网站上验证过的 Python 参考实现。基准字节和 37 个请求的语料把这些行为带进 Rust 程序。套接字测试和对构建出的二进制做的冒烟测试，再把它带进发布版本，每个操作系统一个文件。"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 700 508" aria-hidden="true" focusable="false">
<rect class="d-panel" x="2" y="2" width="696" height="84" rx="14"></rect>
<text class="d-label" x="24" y="38" font-size="20">厂商的程序</text>
<text class="d-sub" x="24" y="66" font-size="17">银行页面本来就期望的东西</text>
<path class="d-line" style="fill:none;stroke-width:2" d="M48,86 V132"></path>
<path class="d-head" d="M48,142 l-6.5,-11 h13 z"></path>
<text class="d-sub" x="72" y="120" font-size="17">观察：页面问什么，程序答什么</text>
<rect class="d-box" x="2" y="142" width="696" height="84" rx="14"></rect>
<text class="d-label" x="24" y="178" font-size="20">Python 参考实现</text>
<text class="d-sub" x="24" y="206" font-size="17">在真实网站上验证过</text>
<path class="d-line" style="fill:none;stroke-width:2" d="M48,226 V272"></path>
<path class="d-head" d="M48,282 l-6.5,-11 h13 z"></path>
<text class="d-sub" x="72" y="260" font-size="17">基准字节，以及应答完全一致的 37 个请求语料</text>
<rect class="d-box" x="2" y="282" width="696" height="84" rx="14"></rect>
<text class="d-label" x="24" y="318" font-size="20">Rust 程序</text>
<text class="d-sub" x="24" y="346" font-size="17">同样的字节，同样的拒绝</text>
<path class="d-line" style="fill:none;stroke-width:2" d="M48,366 V412"></path>
<path class="d-head" d="M48,422 l-6.5,-11 h13 z"></path>
<text class="d-sub" x="72" y="400" font-size="17">套接字测试，然后对构建出的二进制做冒烟测试</text>
<rect class="d-box" x="2" y="422" width="696" height="84" rx="14"></rect>
<text class="d-label" x="24" y="458" font-size="20">发布</text>
<text class="d-sub" x="24" y="486" font-size="17">每个操作系统一个文件</text>
</svg>
</div><figcaption>每个箭头都是下一个阶段必须通过的一组检查。</figcaption>
</figure>


<h3 class="relative group">来自 Python 的基准字节
    <div id="来自-python-的基准字节" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e6%9d%a5%e8%87%aa-python-%e7%9a%84%e5%9f%ba%e5%87%86%e5%ad%97%e8%8a%82" aria-label="锚点">#</a>
    </span>
    
</h3>
<p>有一个存放测试夹具的文件夹，里面是 Python 版本的输出：一条编码后的设备记录、它压缩后的形式、一些加密输出、Python 版本签发的一个证书颁发机构，以及几个戳记。Rust 的测试拿自己的结果和这些字节比对。</p>
<p>这类夹具能回答一些普通单元测试可能不知不觉就重新定义掉的问题。压缩后的数据流，和 Python 版本背后调用的 C 库的输出是否逐字节一致？字段顺序有没有变？旧版本创建的证书颁发机构，在新版本续签服务器证书时还能不能用？</p>

<h3 class="relative group">覆盖所有角色的请求语料
    <div id="覆盖所有角色的请求语料" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e8%a6%86%e7%9b%96%e6%89%80%e6%9c%89%e8%a7%92%e8%89%b2%e7%9a%84%e8%af%b7%e6%b1%82%e8%af%ad%e6%96%99" aria-label="锚点">#</a>
    </span>
    
</h3>
<p>我让 Python 服务器和 Rust 服务器并排运行，用一套 37 个请求的语料去测，覆盖所有角色和传输方式，被拒绝的情况也在内。JSON 相似不算通过。状态行、CORS 头、内容类型和响应体都必须完全相同。</p>
<p>拒绝的情况理应放进这套语料。参考实现拒绝的请求，替代实现却返回成功，那就是改变了安全行为，我不认为这叫兼容。</p>

<h3 class="relative group">真实的套接字和构建出来的程序
    <div id="真实的套接字和构建出来的程序" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e7%9c%9f%e5%ae%9e%e7%9a%84%e5%a5%97%e6%8e%a5%e5%ad%97%e5%92%8c%e6%9e%84%e5%bb%ba%e5%87%ba%e6%9d%a5%e7%9a%84%e7%a8%8b%e5%ba%8f" aria-label="锚点">#</a>
    </span>
    
</h3>
<p>单元测试之上，还有套接字测试和针对发布二进制的冒烟测试。冒烟测试会启动真正的程序，然后要求它的 status 命令确认每个固定端口都在用新的本地证书应答。CI 在 macOS、Linux 和 Windows 上对 Rust 代码做 lint 和测试，Python 的 wheel 由另一个任务单独构建。发布工作流会在每个目标平台上再跑一遍测试，构建，对构建出来的东西做冒烟测试，然后才打包。</p>

<h2 class="relative group">加固也是兼容性的一部分
    <div id="加固也是兼容性的一部分" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e5%8a%a0%e5%9b%ba%e4%b9%9f%e6%98%af%e5%85%bc%e5%ae%b9%e6%80%a7%e7%9a%84%e4%b8%80%e9%83%a8%e5%88%86" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>一个会交出设备信息的本地服务，就算从不接触密码，也是敏感的。任何网站都能在 script 标签或 WebSocket 里指名 localhost 的端口，而 CORS 两样都拦不住。</p>
<p>所以这个程序在每个角色、每种传输方式上都检查调用方。它读取 <code>Origin</code>、<code>Referer</code> 和 <code>Sec-Fetch-Site</code>，拒绝意料之外的 <code>Host</code>，只应答允许列表里的银行来源。证书颁发机构只能为 <code>127.0.0.1</code>、<code>localhost</code> 以及戳记页面调用的那一个主机名签名。它的私钥留在用户的数据文件夹里，而在一次性容器里运行时，密钥根本不会写到磁盘上。</p>
<p>键盘加密和证书签名没有实现，所以会返回明确的错误。没有任何地方伪造加密输出，也没有任何地方假装安装或更新成功。</p>
<p>这些都不是改写之后才加上去的。它们本来就是行为的一部分，所以改写必须原样带过去。</p>

<h2 class="relative group">如果你想照着做
    <div id="如果你想照着做" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e5%a6%82%e6%9e%9c%e4%bd%a0%e6%83%b3%e7%85%a7%e7%9d%80%e5%81%9a" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>这样分工行得通，是因为每个阶段对“完成”的定义都不一样。</p>
<ol>
<li>先画地图，再实现。让第一个智能体去读浏览器代码、localhost 调用和带状态的请求序列，并把观察到的和还只是猜测的分开记。</li>
<li>做一个小的参考实现。Python 对我来说合适：迭代快，变换逻辑好读，还能用合成数据做加解密的往返测试。</li>
<li>尽量少碰真实服务。对比新取到的响应，把不一致缩小到一处，不要对着线上服务盲目重试。</li>
<li>换语言之前，先把行为固化成夹具：基准字节、请求语料和失败用例，而且都不含机密。</li>
<li>让第二个智能体对照这份契约去重构。让它负责模块边界、带类型的错误、并发、打包和 CI，不要让它重新解读协议。</li>
<li>测你要发布的东西，也就是每个目标平台上的发布二进制。库能 import、编译没报错，都说明不了这一点。</li>
<li>自己读 diff。智能体能装下很多上下文，但它没法替你决定法律上的边界、愿意承担多少风险，以及兼容到底该意味着什么。</li>
</ol>
<p>如果探索和重构同时进行，把 git worktree 分开会省不少事。不分开的话，一处探索性的修改和一次结构性的改写可能在测试跑起来之前就互相覆盖了。这件事我写在了<a href="https://jared.lynskey.co.nz/zh-cn/posts/2026/claude-code-git-worktrees/" >Claude Code worktree 如何使用</a>里。</p>

<h2 class="relative group">下次我还会这么做
    <div id="下次我还会这么做" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%e4%b8%8b%e6%ac%a1%e6%88%91%e8%bf%98%e4%bc%9a%e8%bf%99%e4%b9%88%e5%81%9a" aria-label="锚点">#</a>
    </span>
    
</h2>
<p>效果最好的提示词，既不是“逆向这个产品”，也不是“用 Rust 重写它”，而是一连串更窄的任务：</p>
<ul>
<li>还原这个请求的确切编码，并用本地往返测试证明。</li>
<li>解释官方响应和参考实现响应之间的差别，不许猜。</li>
<li>替换实现，同时保持这些字节不变。</li>
<li>只要行为有任何变化，就让发布失败。</li>
</ul>
<p>这个顺序也让我知道一次失败该归到哪里。协议不一致就回到探索阶段，夹具坏了回到改写阶段，打包失败回到发布阶段。两个工具最有用的时候，都是由证据而不是它们自己的信心来决定下一步。Python 夹在两者中间，给了它们各自一个要守住的具体东西。</p>
]]></content:encoded>
      <media:content url="https://jared.lynskey.co.nz/en/posts/2026/kimi-claude-python-rust-modernization/featured.jpg" medium="image" type="image/jpeg" />
    </item>
  </channel>
</rss>
