Part II: Prior Art and the Design Space¶
We place Sibuna among the systems it learned from: client puzzles and sequential work from the cryptography literature, signature and semantic application firewalls, proof-of-work interstitials, and hosted edge networks. We then compare the four tools an operator is most likely to weigh against each other, feature by feature, and record which facts were checked.
Where Sibuna Comes From¶
Client Puzzles and Sequential Work¶
Dwork and Naor’s “Pricing via Processing” (CRYPTO 1992) proposed that a service require a moderately hard, easily checked computation before doing work for a requester. Back’s Hashcash (1997, written up in 2002) made the puzzle a partial hash inversion whose difficulty is one integer, and Juels and Brainard’s client puzzles (NDSS 1999) applied the idea to connection floods, where the server must not remember anything about an unsolved puzzle. All three share the shape Sibuna keeps: a server-chosen statement, a solution whose cost is tunable, and verification that is orders of magnitude cheaper than solving.
Hash search is embarrassingly parallel, so a requester with more cores finishes sooner. Mahmoody, Moran, and Vadhan (CRYPTO 2013) defined proofs of sequential work, in which the prover must perform a long chain of dependent steps whatever its core count, and Cohen and Pietrzak (EUROCRYPT 2018) gave the simple hash-graph construction whose verifier needs only \(O(t \log N)\) work. Blocki, Lee, and Zhou (ITC 2021) proved the same construction sound against quantum provers in the quantum random-oracle model. Part III derives Sibuna’s Tier Two from that line of work; SID 0006 records the assumptions.
Application Firewalls¶
The first generation of web application firewalls matched request bytes against regular expressions. ModSecurity (2002) and the OWASP Core Rule Set made that approach open and widely deployed, and also made its costs familiar: hundreds of backtracking patterns per request, anomaly scores tuned by hand, and a long tail of false positives on ordinary input. libinjection (Hanson, 2012) replaced pattern lists with a tokenizer that asks whether a string parses as SQL, cutting both cost and false positives. Chaitin’s SafeLine carries that semantic idea into a full product, and Hyperscan (Wang et al., NSDI 2019) showed how far vectorised literal matching can be pushed when inputs are long. Part VI explains why Sibuna chose a dense automaton plus small structural tokenizers over either regular expressions or a SIMD engine for the short fields it inspects.
Interstitials and Edges¶
The proof-of-work interstitial in front of a website became common in 2025, when scraper traffic feeding language-model training made ordinary origins unaffordable to run. Anubis (Techaro) is the best-known open implementation: a Go reverse proxy that serves a JavaScript puzzle, signs a session token, and otherwise passes traffic through. Sibuna’s Gate surface solves the same problem with a stateless challenge, a symmetric token, and a second work tier; the comparison below records where the two differ.
At the other end of the scale, hosted edges such as Cloudflare place inspection, rate limiting, and bot scoring in hundreds of points of presence with a global control plane. Sibuna’s Edge deployment borrows the shape (a shared policy and reputation plane feeding local, immutable snapshots) while staying self-hosted, which is why the storage layer is a database the operator runs (a SQLite file on one node, one PostgreSQL database shared by a cluster) read by a storage thread off the request path, rather than a service call.
Three Ideas in One Binary¶
Sibuna combines a browser work challenge for admission, bounded application-payload inspection, and a shared control plane that publishes local policy snapshots. Gate and Shield are the two product surfaces; storage and distributed deployment are options for either.
| Property | Gate | Shield |
|---|---|---|
| Admission | Native Hashcash or sequential-work verification | Same |
| Session | Keyed BLAKE3; optional Ed25519 | Same |
| Local controls | Rules, CIDRs, GCRA, bans | Same |
| Inspection | Disabled | Bounded signatures and structural tokenizers |
| State | Optional persistent policy and reputation, shared across a cluster | Also inspection forensics |
The browser solver compiles from the same proof sources as the native verifier. Dense literal matching avoids backtracking and keeps scan work linear in input length. Immutable policy snapshots isolate request handling from SQL and from the availability of the database. None of these choices establishes universal algorithmic optimality: short headers, long bodies, pattern diversity, core count and cache size change the tradeoffs.
Feature Comparison¶
The four tables below compare Sibuna with the three tools most often mentioned alongside it. Facts about the other products were read from their public documentation and release artefacts in September 2026: Anubis 1.27.0 (MIT licence, Go), SafeLine community edition 9.x (GPL-3.0 management code around closed detector images, Docker Compose), and the Cloudflare WAF developer documentation. Anubis was also run on the benchmark host; SafeLine and Cloudflare were not (Part VIII explains why). A dash means the product does not offer the feature; a plan name means the feature exists but only on that plan. Each Sibuna measurement names the committed result file it comes from. The TLS fingerprint row was checked in October 2026, against the Anubis changelog (1.21.0 and 1.26.0), the SafeLine release notes (8.10.0 and 9.2.0), and Cloudflare’s page “JA3/JA4 fingerprint”.
| Feature | Sibuna | Anubis 1.27 | SafeLine CE 9 | Cloudflare WAF |
|---|---|---|---|---|
| Runs as | One binary; reverse proxy or forward auth; optional SQLite file or shared PostgreSQL database | One Go binary; reverse proxy or forward auth | Seven Docker containers (tengine, detector, mgt, luigi, fvm, chaos, PostgreSQL) | Hosted network; DNS points at Cloudflare |
| Language, runtime | Rust, no garbage collector; no external crate when storage is off | Go, garbage collected | C/C++ proxy and detector, Go management, PostgreSQL | Proprietary edge software |
| Licence | LGPL-3.0-or-later | MIT | GPL-3.0 management code; closed detector images | Proprietary service |
| Host footprint | 35.7 MiB binary (benchmarks/results/comparison-latest.json); 5.9 MiB idle RSS (benchmarks/results/primitives-latest.json); at most 16.0 MiB peak RSS under load (benchmarks/results/product-latest.md) |
38.1 MiB binary; 21 MiB idle RSS; Linux fixture, console off | 1 CPU core, 1 GB RAM, 5 GB disk minimum, Docker 20.10+ | None on premises |
| Feature | Sibuna | Anubis 1.27 | SafeLine CE 9 | Cloudflare WAF |
|---|---|---|---|---|
| Proof-of-work admission | Hashcash (bit-level) and Cohen-Pietrzak sequential work, chosen per rule; WebAssembly with JavaScript fallback | SHA-256 Hashcash in hex nibbles (fast, slow); non-work metarefresh and preact challenges |
JavaScript anti-bot challenge and CAPTCHA; not work-bound | Managed challenge, JS challenge, Turnstile; Bot Fight Mode issues a compute challenge |
| Challenge state on the server | None until solved; solved tags in a fixed Robin Hood table | Store backend: memory, bbolt, Valkey, or S3 | Managed by the stack | Managed by Cloudflare |
| Session token | Keyed BLAKE3 tag, 75-character cookie bound to the work paid; Ed25519 optional | JSON Web Token signed with Ed25519; HS512 optional | Cookie issued by the stack | cf_clearance cookie |
| Post-quantum posture of the default token | Symmetric: only Grover’s quadratic speedup applies | Ed25519: broken by Shor’s algorithm | Not documented | Not documented |
| Policy language | JSON rules: path, User-Agent, headers, IPv4/IPv6 CIDR, JA4 fingerprint; ALLOW, DENY, CHALLENGE, WEIGH with thresholds; dynamic rules from the database | YAML/JSON bots: regex on UA, path, headers; CIDR; CEL expressions; WEIGH with thresholds | Console-defined custom rules, ACLs, IP groups | Rules language expressions; 5 / 20 / 100 / 1000 custom rules by plan |
| TLS fingerprint (JA4) | Rules match a JA4 fingerprint exactly or by prefix; a trusted ingress computes it and forwards it in a header (--ja4-header); Sibuna does not compute it |
Not documented; policies may reference the HTTP fingerprint JA4H, which Anubis computes and adds as the header X-Http-Fingerprint-JA4H |
Computed at its own TLS termination; shown in attack details; custom rules match it (equals, not equals); a built-in rule denies fingerprints from its malicious JA4 intelligence | JA3 and JA4 fingerprints in WAF custom rules and analytics (Enterprise with Bot Management) |
| Feature | Sibuna | Anubis 1.27 | SafeLine CE 9 | Cloudflare WAF |
|---|---|---|---|---|
| SQLi, XSS, RCE, traversal inspection | Shield: tagged automaton plus structural tokenizers, first 8 KB of body | - | Semantic analysis engine over OWASP categories, also SSRF, XXE, CRLF | Managed rulesets (Pro and above); OWASP Core Ruleset; attack score (Business and above) |
| Rate limiting | GCRA per client, local to a node | - (system load is exposed to CEL rules) | Per IP, path, session | 1 / 2 / 5 / 100 rules by plan; IP-only keys below Enterprise |
| Bans and reputation | Honeypot bans; reputation trie loaded from the reputation table shared across the cluster | DNSBL; ASN and GeoIP through Thoth (paid, closed) | IP groups and blacklists; threat intelligence (Pro) | IP lists; managed lists and bot score (Enterprise) |
| Forensics | SQLite or PostgreSQL: full-text search over incidents, vector campaign clustering | Prometheus metrics only | PostgreSQL attack log with console | Security Events; sampled on Free |
| Multi-node | One PostgreSQL database shared by every node for policy and reputation; shared seed; sticky challenge verification | Shared signing key; shared Valkey store | One stack per host | Global anycast |
| Feature | Sibuna | Anubis 1.27 | SafeLine CE 9 | Cloudflare WAF |
|---|---|---|---|---|
| Metrics | Prometheus at /__sibuna/metrics |
Prometheus on a separate port | Console dashboards | Dashboard and analytics |
| TLS termination | - (ingress) | - (ingress) | Yes | Yes |
| Management console | Opt-in; SID 0007 Committed | - | Yes | Yes |
| Measured on the benchmark host | Yes (Part VIII) | Yes | - (Docker only) | - (hosted) |
Three differences carry most of the weight in a selection decision.
- Where the work goes. Anubis and Sibuna Gate make the client pay before the origin does anything. SafeLine and Cloudflare inspect first and challenge selectively; their default posture is to admit and filter. Sibuna Shield does both, in that order: inspection can deny a request that already holds a valid session.
- What the server remembers. Anubis keeps challenge state in a store (memory, bbolt, Valkey, or S3) and signs a JSON Web Token with Ed25519; Sibuna issues a self-authenticating record and remembers only solved tags in a fixed table. SafeLine keeps attack logs in PostgreSQL; Cloudflare keeps everything, with sampled visibility on the Free plan.
- What an operator has to run. Sibuna is one binary with an optional SQLite file, or a PostgreSQL database shared by a cluster; Anubis is one Go binary; SafeLine is seven containers behind a Docker daemon on a Linux host with at least one core, one gigabyte of memory, and five gigabytes of disk; Cloudflare is a DNS change and a subscription.