第 VII 部分:浏览器端的工作量证明引擎¶
我们考察由服务器自己的验证器 crate 编译而成的 WebAssembly 模块、Web Worker 协议、JavaScript 后备证明器,以及验证中间页。
一份源码,两个目标¶
构建方式¶
浏览器求解器编译的正是服务器用来验证的那些源码。cmd/sibuna-pow-wasm 是一个类型为 cdylib 的 no_std 库 crate,为 wasm32-unknown-unknown 构建,它仅有的依赖是工作区 crate sibuna-pow 和 sibuna-crypto:
# cmd/sibuna-pow-wasm/Cargo.toml
[lib]
crate-type = ["cdylib", "rlib"]
[dependencies]
sibuna-crypto = { workspace = true }
sibuna-pow = { workspace = true }
# Cargo.toml(工作区根目录):模块按体积优化构建
[profile.release.package.sibuna-pow-wasm]
opt-level = "z"
debug = false
strip = true
守护进程内嵌了这个模块。它的构建脚本(cmd/sibuna/build.rs)运行一次嵌套的 cargo rustc -p sibuna-pow-wasm --target wasm32-unknown-unknown --profile wasm,输出到工作区的目标目录(target/wasm32-unknown-unknown/wasm/)中。嵌套构建只锁定 wasm profile 的目录,因此从不等待外层构建。最终链接时加上 --compress-relocations。脚本检查结果是否以 WebAssembly 魔数字节开头,然后把它复制到构建输出目录。对于没有 WebAssembly 目标的构建,SIBUNA_POW_WASM=<path> 可以改为嵌入一个预先构建的模块。然后,守护进程把这些字节包含进它的可执行文件:
/// 浏览器求解器,由 `build.rs` 从 `cmd/sibuna-pow-wasm` 构建。
pub const WASM_SOLVER: &[u8] =
include_bytes!(concat!(env!("OUT_DIR"), "/sibuna-pow.wasm"));
/// 求解器所用的 Web Worker。
pub const WORKER_JS: &str = include_str!("../../../web/worker.js");
不存在会发生漂移的第二份实现。守护进程在 /__sibuna/wasm/sibuna-pow.wasm 提供这个模块,并带有一小时的缓存头(Cache-Control: public, max-age=3600)。用上面的 profile 构建时,包含两层的模块大小为 14,744 字节(benchmarks/results/primitives-latest.json 中的 wasm_bytes)。
导出¶
模块导出六个函数,worker 脚本按名称调用它们:
| 导出函数 | 用途 |
|---|---|
sibuna_get_buffer_ptr() / sibuna_get_buffer_len() |
256 字节的输入缓冲区,worker 把挑战字符串写入其中 |
sibuna_solve_step(ptr, len, bits, start, max_steps) |
Hashcash:从 start 开始搜索 max_steps 个 nonce;返回找到的 nonce 或全 1 的哨兵值 |
sibuna_solve_sha256(ptr, len, bits) |
从 nonce 0 开始一次性批量求解 Hashcash(步数为 u32::MAX 的 sibuna_solve_step) |
sibuna_posw_solve(len, depth, challenges) |
顺序工作量:对缓冲区运行证明器,并返回证明长度,参数无效时返回 0 |
sibuna_posw_proof_ptr() |
证明器工作空间中证明字节的起始位置 |
证明器的工作空间(保留的顶部各层、兄弟标签栈和证明)是一块约 92 KiB 的静态区域;没有链接任何分配器,模块也没有任何导入。Workspace::new 是一个 const fn,因此这块静态区域只占用清零的内存,而不是模块中已初始化的数据。
#[unsafe(no_mangle)]
pub unsafe extern "C" fn sibuna_solve_step(
challenge_ptr: *const u8,
challenge_len: usize,
difficulty_bits: u32,
start_nonce: u64,
max_steps: u32,
) -> u64 {
let challenge: &[u8] = if challenge_len == 0 {
&[]
} else {
// SAFETY: 调用者保证 `challenge_ptr` 处有 `challenge_len` 个可读字节,
// 并且它们在调用期间保持不变。
unsafe { core::slice::from_raw_parts(challenge_ptr, challenge_len) }
};
Search::new(challenge)
.find(difficulty_bits, start_nonce, u64::from(max_steps))
.unwrap_or(EXHAUSTED)
}
这些导出函数是该 crate 的外部函数边界,也是它的 unsafe 代码唯一所在的地方。输入缓冲区和证明器工作空间是位于 ExportCell 中的静态变量;这个类型是对 UnsafeCell 的封装,被声明为 Sync,并写明了理由:没有共享内存的 WebAssembly 实例只运行一个线程,而每个导出函数都在返回之前创建、使用并丢弃它的引用,因此任何时刻至多只有一个指向单元的引用是活跃的。在宿主机上,测试直接调用导出函数,此时由一个仅用于测试的互斥锁让它们串行执行。panic 会触发陷阱(unreachable 指令),而不是格式化一条消息,这使模块不含格式化代码和导入;从构造上说 panic 是不可达的,因为 sibuna-pow 的函数都是全函数,从不 panic。
前缀预哈希¶
Hashcash 的内层循环只吸收一次挑战和冒号,然后为每个 nonce 克隆 SHA-256 状态,因此每个候选只需一次压缩,而不是两次。搜索由 sibuna_pow::hashcash::Search 实现,浏览器模块和原生参考求解器共用它:
pub fn new(challenge: &[u8]) -> Self {
let mut prefix = Sha256::new();
prefix.update(challenge);
prefix.update(b":");
Self { prefix }
}
pub fn digest(&self, nonce: u64) -> Digest {
let mut buf = [0u8; NONCE_DIGITS_MAX];
let mut hasher = self.prefix.clone(); // 按值复制已吸收的前缀
hasher.update(format_decimal(nonce, &mut buf));
hasher.finalize()
}
pub fn find(&self, bits: u32, start: u64, steps: u64) -> Option<u64> {
let mut nonce = start;
for _ in 0..steps {
if meets_bits(&self.digest(nonce), bits) {
return Some(nonce);
}
nonce = nonce.wrapping_add(1);
}
None
}
哈希器状态是一个约 110 字节的普通值,因此克隆的成本很低。顺序工作量证明器使用同样的技巧:陈述 \(\chi\) 在 base_hasher 中只吸收一次,然后为每个节点克隆;验证器现在也是如此:它从一个已经吸收过陈述的状态派生每个被挑战的叶子,这使验证在得到相同摘要的同时少做 \(t\) 次压缩。
在服务器上,压缩函数使用 x86-64 SHA 扩展或 ARMv8 SHA-2 指令,在运行时检测。浏览器中没有这样的指令,求解器几乎把所有时间都花在可移植的压缩函数上(crates/crypto/src/sha256/portable.rs)。这个函数是为 WebAssembly 编写的:64 轮全部展开,消息调度保存在一个 16 字的窗口中,从第 16 轮起,每一轮都覆盖它不再需要的那个字,八个工作变量在轮与轮之间重命名,而不是移位:
fn compress_block(state: &mut State, block: &Block) {
let mut w = [0u32; 16];
for (word, bytes) in w.iter_mut().zip(block.as_chunks::<4>().0) {
*word = u32::from_be_bytes(*bytes);
}
let [mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut h] = *state;
eight_rounds!(w, 0, a, b, c, d, e, f, g, h);
eight_rounds!(w, 8, a, b, c, d, e, f, g, h);
// ... 第 16 到 55 轮
eight_rounds!(w, 56, a, b, c, d, e, f, g, h);
for (word, value) in state.iter_mut().zip([a, b, c, d, e, f, g, h]) {
*word = word.wrapping_add(value);
}
}
/// 返回消息调度字 W(i);从第 16 轮起就地计算它。
#[inline(always)]
fn schedule(w: &mut [u32; 16], i: usize) -> u32 {
if i >= 16 {
let w15 = w[(i + 1) % 16];
let w2 = w[(i + 14) % 16];
let s0 = w15.rotate_right(7) ^ w15.rotate_right(18) ^ (w15 >> 3);
let s1 = w2.rotate_right(17) ^ w2.rotate_right(19) ^ (w2 >> 10);
w[i % 16] = w[i % 16]
.wrapping_add(s0)
.wrapping_add(w[(i + 9) % 16])
.wrapping_add(s1);
}
w[i % 16]
}
每个 eight_rounds! 是变量名的一次完整轮换:宏在每一轮把它们轮转一个位置后传入,因此一轮只写入其中两个变量,从不移动另外六个。由于轮次索引是字面量,每个调度位置都是常量,整个分组变成直线代码,其值始终保存在 WebAssembly 局部变量中。这种布局在 V8 中比使用 64 字调度和未展开循环的写法快约 20%,在原生环境中快约 14%(在 Rust 实现上测量,2026 年 10 月)。
Worker 协议¶
页面向 web/worker.js 发送一条消息,并接收进度、后备和结果消息:
// 页面 -> worker
{ challenge: spec.id, algorithm: spec.algorithm, difficulty: spec.difficulty,
challenges: spec.challenges }
// worker -> 页面
{ type: 'progress', iterations: 40000 }
{ type: 'fallback', message: 'Wasm unavailable; running JS prover' }
{ type: 'solved', challenge: spec.id, solution: { nonce: '90766' } } // hashcash
{ type: 'solved', challenge: spec.id, solution: { proof: '<base64url>' } } // posw
{ type: 'error', message: '...' }
worker 先尝试 WebAssembly;当 WebAssembly 不存在、被策略阻止或实例化失败时,回退到纯 JavaScript。JavaScript 证明器逐个标签地镜像 sibuna-pow 的 Rust 证明器,产生 逐字节相同 的输出。测试为两层都固定了 nonce 和证明,SID 0010 要求求解器在无头浏览器中,无论使用 WebAssembly 还是 JavaScript 后备,都能通过。JavaScript 证明器慢得多,但它保证每个浏览器都能通过。
校准¶
不要根据一台笔记本电脑的平均求解时间来选择难度。Hashcash 有几何分布的尾部;浏览器中的计时包括调度、温度状态、启动和编译。部署时的校准应当记录浏览器版本、设备、算法、参数,以及多次重复求解的分布。把模块的获取和编译与稳态哈希分开。
仓库中的原生原语测量结果,不能作为对手机或浏览器求解时间作出承诺的证据。WASM 模块可以执行相同的算术,但启动、执行和内存成本都不同:在原生环境中,服务器用 SHA-NI 计算哈希,而浏览器运行的是上面那个可移植的压缩函数。worker 的消息构成了一个边界,可以在这里测量这些成本,而无需在服务器的请求处理器中加入计时器。
验证中间页¶
这个页面(web/challenge.html,内嵌在守护进程中)是一个单独的 HTML 文件,包含一张卡片、一个不确定进度条和一行状态文字。它为自己的位置请求挑战(?path=),启动 worker,用 fetch 提交解答,成功后重新加载;fetch 调用会以带抖动的指数退避重试,验证返回 4xx 时会显示其诊断标题。页面的 Content-Security-Policy 通过 SHA-256 哈希只允许一个脚本,即求解器代码块,该哈希由守护进程从内嵌页面计算一次得出。一个位于屏幕外的蜜罐链接(/__sibuna/honeypot)对人和执行脚本的浏览器都不可见;盲目跟随每个 href 的爬虫会让自己被封禁。