Teil VII: Die Proof-of-Work-Engine im Browser¶
Wir betrachten das WebAssembly-Modul, das das Verifizierer-Crate des Servers selbst kompiliert, das Web-Worker-Protokoll, die JavaScript-Fallback-Beweiser und die Zwischenseite.
Eine Quelle, zwei Ziele¶
Verdrahtung des Builds¶
Der Browser-Löser kompiliert genau die Quellen, mit denen der Server verifiziert. cmd/sibuna-pow-wasm ist ein no_std-Bibliotheks-Crate vom Typ cdylib, gebaut für wasm32-unknown-unknown, dessen einzige Abhängigkeiten die Workspace-Crates sibuna-pow und sibuna-crypto sind:
# cmd/sibuna-pow-wasm/Cargo.toml
[lib]
crate-type = ["cdylib", "rlib"]
[dependencies]
sibuna-crypto = { workspace = true }
sibuna-pow = { workspace = true }
# Cargo.toml (Wurzel des Workspace): Das Modul wird auf Größe optimiert gebaut
[profile.release.package.sibuna-pow-wasm]
opt-level = "z"
debug = false
strip = true
Der Daemon bettet das Modul ein. Sein Build-Skript (cmd/sibuna/build.rs) führt ein verschachteltes cargo rustc -p sibuna-pow-wasm --target wasm32-unknown-unknown --profile wasm in das Zielverzeichnis des Workspace aus (target/wasm32-unknown-unknown/wasm/). Der verschachtelte Build sperrt nur die Verzeichnisse des Profils wasm und wartet daher nie auf den äußeren Build. Der abschließende Link erhält --compress-relocations. Das Skript prüft, dass das Ergebnis mit den magischen Bytes von WebAssembly beginnt, und kopiert es in das Ausgabeverzeichnis des Builds. SIBUNA_POW_WASM=<path> bettet stattdessen ein vorgefertigtes Modul ein, für Builds ohne das WebAssembly-Ziel. Der Daemon nimmt die Bytes dann in seine Binärdatei auf:
/// Der Löser für den Browser, von `build.rs` aus `cmd/sibuna-pow-wasm` gebaut.
pub const WASM_SOLVER: &[u8] =
include_bytes!(concat!(env!("OUT_DIR"), "/sibuna-pow.wasm"));
/// Der Web Worker des Lösers.
pub const WORKER_JS: &str = include_str!("../../../web/worker.js");
Es gibt keine zweite Implementierung, die auseinanderlaufen könnte. Der Daemon liefert das Modul unter /__sibuna/wasm/sibuna-pow.wasm mit einem Cache-Header für eine Stunde aus (Cache-Control: public, max-age=3600). Mit dem obigen Profil gebaut, misst das Modul mit beiden Stufen 14.744 Bytes (wasm_bytes in benchmarks/results/primitives-latest.json).
Exporte¶
Das Modul exportiert sechs Funktionen, und das Worker-Skript ruft sie beim Namen auf:
| Export | Zweck |
|---|---|
sibuna_get_buffer_ptr() / sibuna_get_buffer_len() |
256-Byte-Eingabepuffer, in den der Worker die Challenge-Zeichenkette schreibt |
sibuna_solve_step(ptr, len, bits, start, max_steps) |
Hashcash: durchsucht max_steps Nonces ab start; gibt die Nonce oder den Sentinel aus lauter Einsen zurück |
sibuna_solve_sha256(ptr, len, bits) |
Hashcash in einem Batch ab Nonce 0 (sibuna_solve_step mit u32::MAX Schritten) |
sibuna_posw_solve(len, depth, challenges) |
Sequenzielle Arbeit: führt den Beweiser über den Puffer aus und gibt die Länge des Nachweises zurück, oder 0 bei ungültigen Argumenten |
sibuna_posw_proof_ptr() |
Beginn der Nachweisbytes im Arbeitsbereich des Beweisers |
Der Arbeitsbereich des Beweisers, also die behaltenen oberen Ebenen, der Geschwisterstack und der Nachweis, ist ein statischer Bereich von etwa 92 KiB; es ist kein Allokator eingebunden, und das Modul hat keine Importe. Workspace::new ist eine const fn, daher kostet der statische Bereich nur genullten Speicher, keine initialisierten Daten im Modul.
#[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: Der Aufrufer garantiert `challenge_len` lesbare Bytes ab
// `challenge_ptr`, die sich während des Aufrufs nicht ändern.
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)
}
Die Exporte bilden die Fremdfunktionsgrenze des Crates und sind der einzige Ort seines unsafe-Codes. Der Eingabepuffer und der Arbeitsbereich des Beweisers sind statische Variablen in einer ExportCell, einer Hülle um UnsafeCell, die mit angegebener Begründung als Sync deklariert ist: Eine WebAssembly-Instanz ohne gemeinsamen Speicher läuft in einem Thread, und jeder Export erzeugt seine Referenzen, nutzt sie und gibt sie frei, bevor er zurückkehrt, sodass höchstens eine Referenz in eine Zelle zugleich lebt. Auf dem Host, wo die Tests die Exporte direkt aufrufen, serialisiert ein nur für Tests vorhandener Mutex sie. Eine Panic löst einen Trap aus (die Instruktion unreachable), statt eine Meldung zu formatieren; das hält das Modul frei von Formatierungscode und Importen. Panics sind konstruktionsbedingt unerreichbar, weil die Funktionen von sibuna-pow total sind und nie eine Panic auslösen.
Vorab-Hashing des Präfixes¶
Die innere Hashcash-Schleife absorbiert die Challenge und den Doppelpunkt einmal und klont den SHA-256-Zustand pro Nonce, sodass jeder Kandidat eine Kompression statt zwei kostet. Die Suche ist sibuna_pow::hashcash::Search, die das Browsermodul und der native Referenzlöser gemeinsam nutzen:
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(); // Kopie des aufgenommenen Präfixes
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
}
Der Hasher-Zustand ist ein einfacher Wert von etwa 110 Bytes, daher ist das Klonen billig. Der Beweiser für sequenzielle Arbeit nutzt denselben Trick, wobei die Aussage \(\chi\) einmal in base_hasher absorbiert und für jeden Knoten geklont wird, und der Verifizierer tut das inzwischen auch: Er leitet jedes geforderte Blatt aus einem Zustand ab, der die Aussage einmal absorbiert hat. Das macht die Verifikation um \(t\) Kompressionen billiger, bei denselben Digests.
Auf dem Server nutzt die Kompressionsfunktion die SHA-Erweiterungen von x86-64 oder die SHA-2-Instruktionen von ARMv8, zur Laufzeit erkannt. Im Browser gibt es solche Instruktionen nicht, und der Löser verbringt fast seine gesamte Zeit in der portablen Kompressionsfunktion (crates/crypto/src/sha256/portable.rs). Diese Funktion ist für WebAssembly geschrieben: Die 64 Runden sind ausgerollt, der Nachrichtenplan liegt in einem Fenster von 16 Wörtern, in dem jede Runde ab Runde 16 das Wort überschreibt, das sie nicht mehr braucht, und die acht Arbeitsvariablen werden von Runde zu Runde umbenannt, statt verschoben zu werden:
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);
// ... Runden 16 bis 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);
}
}
/// Gibt das Wort W(i) des Nachrichtenplans zurück; ab Runde 16 vor Ort berechnet.
#[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]
}
Jedes eight_rounds! ist eine volle Umdrehung der Variablennamen: Das Makro übergibt sie pro Runde um eine Position rotiert, sodass eine Runde nur zwei von ihnen schreibt und die anderen sechs nie bewegt. Mit einem literalen Rundenindex ist jede Position im Plan eine Konstante, und der ganze Block wird zu geradlinigem Code, dessen Werte in lokalen WebAssembly-Variablen bleiben. Dieses Layout läuft in V8 etwa 20 % schneller als ein Plan mit 64 Wörtern und einer nicht ausgerollten Schleife, und nativ etwa 14 % schneller (gemessen an der Rust-Implementierung, Oktober 2026).
Das Worker-Protokoll¶
Die Seite sendet eine Nachricht an web/worker.js und empfängt Fortschritts-, Fallback- und Ergebnisnachrichten:
// Seite -> Worker
{ challenge: spec.id, algorithm: spec.algorithm, difficulty: spec.difficulty,
challenges: spec.challenges }
// Worker -> Seite
{ 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: '...' }
Der Worker versucht zuerst WebAssembly und weicht auf reines JavaScript aus, wenn WebAssembly fehlt, durch eine Richtlinie blockiert ist oder sich nicht instanziieren lässt. Die JavaScript-Beweiser bilden den Rust-Beweiser von sibuna-pow Label für Label nach und erzeugen byteidentische Ausgabe. Die Tests legen feste Nonces und Nachweise für beide Stufen fest, und SID 0010 verlangt, dass der Löser in einem Headless-Browser sowohl mit WebAssembly als auch mit dem JavaScript-Fallback besteht. Die JavaScript-Beweiser sind viel langsamer, garantieren aber, dass jeder Browser bestehen kann.
Kalibrierung¶
Keine Schwierigkeit aus der durchschnittlichen Lösungszeit eines einzigen Laptops wählen. Hashcash hat ein geometrisches Verteilungsende; Browser-Uhren schließen Scheduling, thermischen Zustand, Start und Kompilierung ein. Eine Kalibrierung für einen Einsatz sollte Browserversion, Gerät, Algorithmus, Parameter und eine Verteilung wiederholter Lösungen festhalten. Abruf und Kompilierung des Moduls getrennt vom Hashen im eingeschwungenen Zustand halten.
Die nativen Primitive-Messungen des Repositorys sind kein Beleg für eine versprochene Lösungszeit auf einem Telefon oder in einem Browser. Ein WASM-Modul kann dieselbe Arithmetik ausführen und dabei andere Start-, Ausführungs- und Speicherkosten haben: Nativ hasht der Server mit SHA-NI, während der Browser die obige portable Kompressionsfunktion ausführt. Die Nachrichten des Workers bilden die Grenze, an der sich diese Kosten messen lassen, ohne dem Anfrage-Handler des Servers einen Timer hinzuzufügen.
Die Zwischenseite¶
Die Seite (web/challenge.html, im Daemon eingebettet) ist eine einzelne HTML-Datei mit einer Karte, einem unbestimmten Fortschrittsbalken und einer Statuszeile. Sie fordert die Challenge für ihre eigene Adresse an (?path=), startet den Worker, sendet die Lösung mit fetch und lädt bei Erfolg neu; fetch-Aufrufe werden mit exponentiellem Backoff mit Jitter wiederholt, und eine Verifikationsantwort 4xx wird mit ihrem Diagnosetitel angezeigt. Die Content-Security-Policy der Seite lässt genau ein Skript zu, den Löserblock, über seinen SHA-256-Hash, den der Daemon einmal aus der eingebetteten Seite berechnet. Ein Honeypot-Link außerhalb des sichtbaren Bereichs (/__sibuna/honeypot) ist für Menschen und für Browser, die Skripte ausführen, unsichtbar; blinde Crawler, die jedem href folgen, sperren sich selbst.