更新功能最怕的不是「更新失败」,而是「更新失败以后回不去」。用户点了升级,下载完成,替换文件,重启,程序打不开。这时候如果旧版本已经被覆盖,用户手里就只剩一个坏掉的软件,只能卸载重装,配置和缓存一起没了。更糟的是支持人员远程排查时发现,回滚脚本执行了,但启动的还是新版本,因为备份文件根本没被用上。

自动更新是一条比普通功能更长的链路:检查版本、下载、校验、备份、替换、启动验证、失败回滚,每一步都可能断。这篇不教你怎么点「发布」,而是把这条链路拆开,先讲版本号这个最容易被轻视的起点,再用一个能跑的替换与回滚实验说明「退得回去」是怎么做到的,最后把签名和 Tauri 的更新插件接上。

版本号不是字符串

「1.10.0 比 1.9.0 新吗?」很多人下意识会说对,但按字符串比较的结果是错的:逐字符比到第二位时,字符 1 小于 9,所以字符串认为 1.10.0 更旧。这个错误会让更新逻辑永远认为「已经是最新」,或者反过来反复提示升级。版本号必须按数字段比较,这就是语义化版本的基本规则:主版本、次版本、修订号,逐段按整数比。

下面这段程序实现了版本解析、比较、完整性校验和替换回滚,只用标准库,完整可编译。为了不引入加密库,完整性校验用 FNV 哈希演示流程,生产环境必须换成 SHA-256 或更强的算法,并且要配签名,后面会讲原因。

use std::fs;
use std::path::{Path, PathBuf};

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct Version {
    major: u64,
    minor: u64,
    patch: u64,
}

impl Version {
    fn parse(text: &str) -> Option<Self> {
        let text = text.trim().trim_start_matches('v');
        let mut parts = text.split('.');
        let major = parts.next()?.parse().ok()?;
        let minor = parts.next()?.parse().ok()?;
        let patch = parts.next().unwrap_or("0").parse().ok()?;
        if parts.next().is_some() {
            return None;
        }
        Some(Version { major, minor, patch })
    }
}

fn fnv1a(bytes: &[u8]) -> u64 {
    let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
    for b in bytes {
        hash ^= *b as u64;
        hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
    }
    hash
}

fn apply(dir: &Path) -> std::io::Result<()> {
    fs::rename(dir.join("app.dat"), dir.join("app.dat.bak"))?;
    fs::rename(dir.join("app.new"), dir.join("app.dat"))?;
    Ok(())
}

fn rollback(dir: &Path) -> std::io::Result<()> {
    fs::rename(dir.join("app.dat"), dir.join("app.new"))?;
    fs::rename(dir.join("app.dat.bak"), dir.join("app.dat"))?;
    Ok(())
}

fn main() {
    let current = Version::parse("1.9.0").unwrap();
    for candidate in ["1.10.0", "1.9.1", "2.0.0", "1.9.0", "1.9"] {
        let version = Version::parse(candidate).unwrap();
        println!(
            "[cmp] {:<8} parsed={:?} newer_than_current={}",
            candidate, version, version > current
        );
    }
    println!(
        "[str] \"1.10.0\" > \"1.9.0\" 按字符串比较 = {}",
        "1.10.0" > "1.9.0"
    );
    println!("[parse] \"1.9.0.1\" -> {:?}", Version::parse("1.9.0.1"));

    let dir: PathBuf = std::env::temp_dir().join("rust-update-demo");
    let _ = fs::remove_dir_all(&dir);
    fs::create_dir_all(&dir).unwrap();

    let old = b"version=1.9.0\nbuild=old\n";
    fs::write(dir.join("app.dat"), old).unwrap();
    println!("[current] {}", String::from_utf8_lossy(&fs::read(dir.join("app.dat")).unwrap()).replace('\n', " | "));

    let package = b"version=1.10.0\nbuild=new\n";
    let expected = fnv1a(package);
    let manifest = format!("version=1.10.0\nhash={:016x}\n", expected);
    fs::write(dir.join("manifest.txt"), &manifest).unwrap();
    println!("[manifest] {}", manifest.replace('\n', " | "));

    let received = b"version=1.10.0\nbuild=new\n";
    let actual = fnv1a(received);
    println!("[verify] expected={:016x} actual={:016x} ok={}", expected, actual, expected == actual);
    fs::write(dir.join("app.new"), received).unwrap();

    apply(&dir).unwrap();
    println!("[apply] {}", String::from_utf8_lossy(&fs::read(dir.join("app.dat")).unwrap()).replace('\n', " | "));
    println!("[apply] bak_exists={}", dir.join("app.dat.bak").exists());

    rollback(&dir).unwrap();
    println!("[rollback] {}", String::from_utf8_lossy(&fs::read(dir.join("app.dat")).unwrap()).replace('\n', " | "));

    let bad = b"version=1.10.0\nbuild=truncated";
    println!("[tampered] hash_ok={}", fnv1a(bad) == expected);
}
rustc -O updater.rs
.\updater.exe
[cmp] 1.10.0   parsed=Version { major: 1, minor: 10, patch: 0 } newer_than_current=true
[cmp] 1.9.1    parsed=Version { major: 1, minor: 9, patch: 1 } newer_than_current=true
[cmp] 2.0.0    parsed=Version { major: 2, minor: 0, patch: 0 } newer_than_current=true
[cmp] 1.9.0    parsed=Version { major: 1, minor: 9, patch: 0 } newer_than_current=false
[cmp] 1.9      parsed=Version { major: 1, minor: 9, patch: 0 } newer_than_current=false
[str] "1.10.0" > "1.9.0" 按字符串比较 = false
[parse] "1.9.0.1" -> None
[current] version=1.9.0 | build=old | 
[manifest] version=1.10.0 | hash=b2dc1638ee5361e3 | 
[verify] expected=b2dc1638ee5361e3 actual=b2dc1638ee5361e3 ok=true
[apply] version=1.10.0 | build=new | 
[apply] bak_exists=true
[rollback] version=1.9.0 | build=old | 
[tampered] hash_ok=false

输出里有三处值得停下来看。第一处是 [cmp] 和 [str] 的对比:同一对版本号,按数字比较是「更新」,按字符串比较是「更旧」。第二处是 [parse] "1.9.0.1" -> None,四段版本号被拒绝,说明解析器对格式是有要求的;真实项目里如果允许预发布标记,比如 1.10.0-beta.1,需要另写规则,不能和正式版混着比。第三处是替换与回滚:替换后旧文件变成备份,回滚把备份换回来,内容都验证过。

哈希校验那一行也值得说明。篡改后的包哈希对不上,更新会被拒绝,这是完整性。但完整性不等于真实性:如果攻击者能改下载包,也能改清单里的哈希,两者一起替换就骗过去了。所以真正的更新必须验证签名,哈希只是快速排错的辅助手段。

在本机这次运行里,篡改后的包得到 hash_ok=false,流程应当停在这一步;如果实现里只是打印日志而继续替换,那么后面的签名校验就成了唯一一道闸。审计更新代码时,先看失败分支有没有 return,比看它算了什么哈希更重要。

更新链路的七个步骤

一条能回滚的更新链路,顺序是固定的。少一步,出问题时就少一条退路。

一次可回滚的更新
读取当前版本并检查远端清单
比较版本,确认是否需要更新
下载安装包到临时目录
校验哈希与签名
备份当前版本
替换文件并启动验证
失败则回滚并上报

第一步的验收标准是:清单能正确解析,网络失败有超时和重试,不会让界面一直转圈。第二步的验收标准是:只在远端严格大于本地时才更新,降级要单独开关。第三步的验收标准是:文件下到临时目录,不直接覆盖安装目录。第四步的验收标准是:哈希和签名都通过,任何一项失败都终止。第五步的验收标准是:备份完整,并且记录了版本号。第六步的验收标准是:新版本能启动并完成一次自检。第七步的验收标准是:回滚后版本号、配置和数据都回到更新前。

Windows 上还有一个特殊约束:正在运行的可执行文件不能被替换。所以更新通常不是「在程序里直接覆盖自己」,而是下载完成后启动一个独立的更新器进程,主程序退出,更新器替换文件,再启动新版本。macOS 和 Linux 的包管理机制不同,但「用独立进程做替换」这个思路是通用的。

还有一点在文档里容易漏:清单是更新器唯一的输入。它至少要能回答「新版本号是多少」「包从哪里下」「包的签名是什么」。本机的密钥生成只解决了最后一项的准备工作,前两项需要你自己搭一个静态文件服务或对象存储。没有这个服务,「检查更新」永远返回空,看起来像「已经是最新版本」,其实是根本没问到东西。

签名、哈希与代码签名不是一回事

三个概念经常被混为一谈,实际防的东西不一样。哈希防的是「文件传坏了或被改动了」,它自己不带任何身份信息。更新签名防的是「这个更新确实是你发布的」,通常用私钥签名、公钥内置在客户端,攻击者改了包就验不过。代码签名防的是「这个程序来自某个可识别的发布者」,Windows 上是 Authenticode,macOS 上是公证,它影响的是系统警告和 SmartScreen 拦截,不直接决定更新逻辑。

哈希校验

下载完成后算一次摘要,和清单里的值比对。实现简单,能发现传输损坏和简单篡改;但如果清单本身也被改,就失去意义。适合做第一道快速检查。

更新签名

用私钥对安装包或清单签名,客户端用内置公钥验证。私钥放在离线环境或受控的发布系统里,泄露等于所有人都能发假更新。这是自动更新的安全底线。

代码签名则是另一层。没有它,Windows 可能弹「未知发布者」,SmartScreen 可能直接拦截下载;企业环境还可能因为证书不受信而阻止安装。它不是更新安全的替代品,但没有它,用户连下载这一步都可能过不去。三者的关系可以记成:签名保证更新是真的,代码签名让系统愿意运行它,哈希保证文件没坏。

密钥管理是更新系统里最不像代码、却最容易出事的部分。私钥泄露以后,攻击者可以签出任何版本的假更新,而且你的客户端会当成真的。常见做法是把私钥放在离线的发布机或硬件密钥里,签名和打包在同一套受控流程中完成,开发机只保留公钥。轮换密钥要提前规划,因为旧客户端只认旧公钥,新密钥要能通过一次正常更新带下去。

本机这一步只做到「把密钥生成出来」:私钥 348 字节,公钥 152 字节。公钥最终要写进客户端配置,所以它必须是能随安装包分发的文本;私钥则相反,一旦进了代码仓库,整个更新体系就等于没有锁。生成成功不等于流程跑通,真正的签名、发布、客户端验签要等有证书和分发环境之后才能补。

Tauri 的更新插件怎么接

Tauri 2 提供官方更新插件,配置在 tauri.conf.json 的 plugins.updater 下,核心是清单地址和公钥。本机的 Tauri CLI 2.12.4 可用,更新器密钥也实际生成过:私钥 348 字节,公钥 152 字节。但真实升级和回滚没有跑过,这一项仍未验证:没有更新服务器,也没有代码签名证书。所以下面这些清单字段和行为仍然按官方文档写,接线时以插件版本为准:

{
  "plugins": {
    "updater": {
      "endpoints": [
        "https://example.com/updates/latest.json"
      ],
      "pubkey": "<你的公钥内容>"
    }
  }
}

清单里描述最新版本、下载地址和签名,客户端拿到后和当前版本比较。pubkey 填的就是本机生成的那 152 字节公钥的文本形式;endpoints 是数组,可以写多个地址,插件按顺序尝试。Rust 侧的调用大致是检查、下载并安装,前端也可以走对应的 JavaScript 插件。示意代码:

use tauri_plugin_updater::UpdaterExt;

async fn check_update(app: &tauri::AppHandle) -> Result<(), String> {
    let updater = app.updater().map_err(|err| err.to_string())?;
    match updater.check().await.map_err(|err| err.to_string())? {
        Some(update) => {
            update
                .download_and_install(|chunk, total| {
                    // 这里做进度显示,注意节流
                    let _ = (chunk, total);
                }, || {
                    // 安装完成回调
                })
                .await
                .map_err(|err| err.to_string())?;
            Ok(())
        }
        None => Ok(()),
    }
}

权限文件里要放开更新相关的权限,否则运行时会报拒绝。和前面几篇一样,这类错误不会在编译期出现,先把控制台打开看清楚是「没有权限」还是「清单格式不对」。

本机对这段接线只验证了两件事:CLI 2.12.4 能正常执行,密钥能生成出来。updater.check() 没有对着真实服务器跑过,download_and_install 也没有执行过,因为本机没有更新服务器,也没有签名证书。这意味着清单里的 version、url、signature 三个字段是否与你的服务端输出对得上,仍然要在第一次联调时确认。别把这里的示例当成「已经验证过的配置」。

更新公钥一旦发布就绑定在旧版本客户端里,换密钥等于旧客户端再也收不到更新。发布前把密钥管理流程定下来,私钥不要放在开发机上,也不要和代码仓库放在一起。

从需求到跑起来:1.9.0 升到 1.10.0

把上面的步骤落到一个具体版本,走一遍完整流程。

本地 1.9.0 请求清单,读到 1.10.0
下载到临时目录,校验签名与哈希
把当前目录备份为 1.9.0 的完整副本
独立更新器替换文件并启动新版本
自检失败则还原备份并上报

验收标准要写死:更新后版本号必须变成 1.10.0;配置目录里的旧键必须还在;自检要覆盖「主窗口能创建」「关键资源能读到」「数据库能打开」三件事;回滚后版本号必须回到 1.9.0,且备份文件不能被删除。任何一项不满足,都算更新失败。

还有一条经常被忽略:更新器和主程序要能互相识别。更新器写完文件后,要记录一个状态标记,主程序启动时读取这个标记,确认「这次是从旧版本升上来的」,然后做一次配置迁移和自检。没有这个标记,主程序无法区分「正常启动」和「刚升级完」,迁移逻辑就不知道什么时候该跑。

本机没有走这一步的实际升级:1.9.0 到 1.10.0 的替换与回滚是在一个纯标准库实验里验证的,更新器插件本身没有参与。要复现完整链路,至少需要三样东西:一个能返回最新清单的 HTTP 地址、一对签名密钥、一个能安装的包。缺任何一样,你都只能验证到「检查更新」之前的逻辑。这是本机目前卡住的地方,如实写在这里。

出了问题先看哪里

现象真实原因第一步查什么
一直提示已是最新版本版本号按字符串比较,或清单被缓存打印本地与远端版本;清缓存再请求
下载完成但安装失败目标文件被占用,或没有写权限看错误码;确认是否用独立更新器
更新后程序打不开包不完整、缺运行库、签名校验被绕过校验哈希与签名;看系统事件日志
更新后配置全丢配置目录随版本变化,或没有迁移对比新旧路径;查迁移代码是否执行
回滚了还是新版本备份没被使用,或替换顺序写反检查备份文件内容与启动路径
杀毒软件拦截更新未签名,或证书不受信查看文件签名状态与证书链
部分用户升级后闪退,部分正常系统版本、运行库或硬件差异收集崩溃转储与系统版本,分批放量
检查更新永远返回「已是最新」清单地址不可达,或版本字段格式不对先用浏览器访问清单地址;核对版本号段数
更新包下载后被系统直接删掉未签名或证书链不受信,被杀毒软件拦截查文件签名状态与安全软件日志

边界与代价

自动更新不是免费的。你要维护清单服务、签名密钥、回滚逻辑,还要考虑网络失败、磁盘空间不足、权限不足、杀毒软件拦截。每一次发布都等于一次小规模的分发系统上线。用户量很小、更新频率很低时,手动发安装包加一个「检查新版本」的链接,可能比全套自动更新更省事。

回滚也不是万能的。数据库结构升级以后,旧版本可能读不了新数据;配置迁移也可能单向。真正的回滚方案要在设计阶段就确定「哪些变更是可逆的」,不可逆的变更要先备份、再迁移,并且给旧版本留一条只读路径。否则所谓回滚,只是把程序换回去,数据已经回不去了。

这台机器上没有更新服务器,也没有签名证书,所以「真实升级、失败、回滚」这条线一次都没有跑。能确认的只有密钥尺寸和插件配置字段;不能确认的是安装包替换时机、失败后的备份是否被正确启用、以及新版本自检失败时界面如何提示。把这些留成待验证项,比写一段「已测试通过」更诚实。

发布节奏也影响回滚策略。全量推送一次到所有人,出问题就是全体事故;分批放量先给 5% 用户,观察崩溃率和启动成功率,再扩大。桌面应用没有服务端那么强的实时监控,但至少可以上报「启动成功」「自检失败」两类事件。

另一个优化方向是增量更新,只下发新旧版本之间的差异,而不是完整安装包。它能把下载量降一个数量级,但代价是要维护每个历史版本到新版本的补丁,发布流程和校验都会变复杂。用户量不大、安装包本身只有十几兆时,先把完整包和回滚做稳,比上增量更新更划算。

当天能验证的练习

  1. 运行 updater.rs,把当前版本改成 1.10.0,观察哪些候选版本会被判定为更新。
  2. 给版本解析加上预发布标记的支持,规定 1.10.0-beta.1 小于 1.10.0。
  3. 把替换顺序故意写反,运行后观察回滚结果,理解「先备份再替换」为什么不能颠倒。
  4. 把哈希校验改成对清单文件也校验,思考这样能防住什么、防不住什么。
  5. 模拟一次自检失败:替换后不启动新版本,直接调用回滚,确认版本号和数据都恢复。
  6. 用 Tauri CLI 生成一对更新密钥,记录私钥和公钥的字节数,把公钥填进配置,确认构建时不报格式错误。

更新链路打通以后,最后一个现实问题是「包有多大、启动有多快」。用户不会因为功能好就容忍一个两百兆的安装包,也不会因为架构优雅就接受双击后等三秒。下一篇讲打包、体积与启动速度,用真实的构建数据看哪些优化有用、哪些只是心理安慰。