OxiRS 0.4.1 Released — Closing a Full Auth Bypass, 300 Fixes from a 308-Finding Hardening Audit

A 38-scope multi-agent audit went looking for stubs, fabricated results, and silent data loss across all 27 crates — it found 308 of them, including a full authentication bypass in the SPARQL server.

Today we released OxiRS 0.4.1 — a workspace-wide production-readiness hardening pass that closes a complete oxirs-fuseki auth bypass, makes Raft storage genuinely fsync-durable, and fixes SPARQL parser bugs that were silently producing wrong query results instead of failing loud.

No C. No Fortran. No JVM. OxiRS’s Pure-Rust dependency tree compiles to a single static binary (or a WASM module) and runs everywhere Rust runs.
0.4.1 is the release where a systematic security and correctness audit went looking for every corner that tree had cut — from an auth layer that was wired up but never actually checked, to a cache that claimed to encrypt data it never touched — and fixed nearly all of it, in public, in the CHANGELOG.

Why OxiRS 0.4.1 is a game changer

Most “production-ready” RDF servers accumulate a specific kind of debt that no benchmark catches:

• Auth middleware that’s present in the code but never actually wired into the request path
• A consensus layer that calls itself durable while keeping all its state in memory
• A conformance test harness that reports green because it fabricates the result, not because the implementation passed
• A SPARQL parser that quietly drops a clause it doesn’t recognize instead of failing the query

OxiRS 0.4.1 pays all four down, out loud:

• The oxirs-fuseki auth bypass is closed. The AuthUser extractor never actually authenticated requests, route_based_rbac failed open on any error, and the /update endpoint had no auth check at all. All three now correctly gate on config.security.auth_required. X.509 client-certificate trust now verifies the actual signature chain instead of comparing DN strings.
• Raft storage is now really durable. A new DurableRaftStore fsyncs every log append and writes hard state/snapshots atomically (write-temp + fsync + rename) — closing the durability gap deliberately deferred from 0.4.0’s Raft integration. A restart can no longer double-vote or lose a committed write.
• The core SPARQL parser stopped lying about what it parsed. It no longer silently drops FILTER clauses; multi-line CONSTRUCT/SELECT/ASK/DESCRIBE queries and UPDATE statements (a newline before WHERE, a multi-PREFIX prologue) now parse correctly instead of misfiring.
• Fabricated results are gone. The W3C SHACL conformance harness no longer fabricates results, oxirs-shacl-ai no longer fabricates quality metrics or AutoML “training,” oxirs-federate’s planner now really decomposes federated queries instead of returning a canned plan, and the performance-validation suite runs genuine end-to-end SPARQL instead of sleep().
• oxirs-did’s revocation checks are real. DID/VC verification now checks credential revocation, consumes the auth challenge (anti-replay), and verifies ZKP selective-disclosure proofs — instead of accepting all three unconditionally.

All from a 308-finding audit (62 P0, 131 P1, 115 P2) across 38 work packages, ~300 fixed, plus 74 test regressions the full-suite gate caught and closed on the way out. 46,255 tests passing with --all-features (45,408 default), zero compilation warnings, across all 27 crates.

Technical Deep Dive: how you find 308 real findings

1. Scope the audit like a security review, not a linter. 38 scan agents ran per-crate, plus five cross-cutting lenses — fail-loud behavior, operational correctness, security, concurrency, and recent-diff risk — each independently verified before being counted. That structure is what catches an auth extractor that compiles cleanly and passes its own unit tests while never being called on the real request path.

2. Fix fabrication at the source, not the assertion. oxirs-shacl’s W3C conformance harness and oxirs-shacl-ai’s quality/AutoML metrics were rewritten to compute what they claim to compute, rather than patching the tests that had encoded the fabricated output as “expected.” The same applies to oxirs-federate’s query planner, which now genuinely decomposes a federated query instead of returning a pre-built plan.

3. Durability means fsync, not “in a struct.” DurableRaftStore in oxirs-cluster persists vote state, log entries, the state machine, and snapshots with an explicit write-temp/fsync/rename sequence — the same discipline oxirs-tdb’s WAL already used, now extended to consensus state. oxirs-tdb’s repair_page_checksums and superblock reads were also fixed to verify a page’s checksum before trusting it, instead of re-stamping a fresh checksum over already-corrupt bytes and reporting success.

4. A parser bug is a data-integrity bug. The oxirs CLI’s tdbupdate was collapsing every literal and blank-node position to an IRI before writing — silently corrupting a TDB-backed store for every other reader (tdbquery, tdbdump). Term kind is now preserved. oxirs-did’s StatusList2021 credential-status encoding is now genuinely GZIP-compressed before base64url, fixing interop with external W3C-compliant verifiers that had been silently failing to decode it.

Getting Started

The oxirs CLI stays intentionally off crates.io (publish = false, so it can optionally pull in C-FFI quarantine adapters without exposing them on a published surface). Build it from source:

git clone https://github.com/cool-japan/oxirs.git
cd oxirs
cargo install --path tools/oxirs

The other 25 OxiRS library crates are normally published — add just the SPARQL engine, or the full query layer:

[dependencies]
oxirs-core = "0.4.1"
oxirs-arq = "0.4.1"

Then put the hardened server to work:

oxirs init mykg --format memory
oxirs import mykg data.ttl --format turtle
oxirs query mykg "SELECT ?s ?p ?o WHERE { ?s ?p ?o } LIMIT 10"
oxirs serve mykg/oxirs.toml --port 3030

What’s New in 0.4.1

• Security — closed the oxirs-fuseki auth/authz bypass end to end; X.509 chain verification instead of DN-string comparison; fixed a SPARQL injection hole in REST API v2 and added SSRF guards on SPARQL LOAD; oxirs-gql’s “AES” cache layer was a plaintext passthrough with always-granting token validation — both fixed; oxirs-did now checks revocation, anti-replay, and ZKP proofs for real; oxirs-chat SAML verification hardened against XML Signature Wrapping
• Data integrity — durable, fsync-backed Raft storage (DurableRaftStore); tdbupdate no longer corrupts term kinds on write; oxirs-tdb checksum verification before trusting page data; genuinely GZIP-compressed StatusList2021
• SPARQL correctness — FILTER clauses are no longer silently dropped; multi-line CONSTRUCT/SELECT/ASK/DESCRIBE/UPDATE parse correctly; Store::flush() actually flushes
• De-fabrication — real SHACL conformance results, real shacl-ai quality metrics/AutoML, real federated query decomposition, real end-to-end benchmark queries instead of sleep()
• Added — SPARQL 1.1 sub-SELECT and Turtle collection/property-list syntax inside query patterns; RDF-vocabulary-driven GraphQL schema auto-generation (graphql_autoschema); an mmap-able RDF store snapshot format for sub-second cold start (versus ~13.6s re-parsing 1.35M quads)
• Removed (breaking) — the GEOS and DuckDB C-FFI quarantine adapters, and the Kafka streaming backend, are gone with no C-toolchain replacement needed

Tips

• Rename --features all-features to --features full-cli in any build script. The old flag silently omitted excel-export and system-keyring; the renamed flag genuinely enables every optional CLI feature.
• On StreamBackendType::Kafka? Migrate now. The Kafka backend (and the oxirs-stream-adapter-rdkafka quarantine crate behind it) is removed outright — it required a C toolchain and was unreachable from any release anyway. Use nats, redis, rabbitmq, mqtt, or memory instead; if you only needed schema validation, confluent_registry now ships Pure-Rust in oxirs-stream with no broker required.
• Drop --features rust-buffer for GeoSPARQL. geo::algorithm::buffer now handles every geometry type unconditionally in Pure Rust — strictly more than the old feature or the GEOS adapter covered, so there’s nothing to opt into anymore.
• If /update started returning 401s you didn’t expect, that’s the fix, not a regression. Auth enforcement now correctly gates on config.security.auth_required — if you run with auth disabled (the default), anonymous writes work as before; if you had auth enabled, gaps that were silently open are now actually closed.
• Migrating off oxirs tsdb duckdb? Export chunks to Parquet via oxirs-tsdb’s arrow-export feature and query them with an external DuckDB — the Pure-Rust analytics::DuckDbQueryAdapter still builds the SQL for you.
• SPARQL UPDATE ... USING/USING NAMED is still a fail-loud parse error, not a supported feature. It’s tokenized but intentionally not yet implemented — don’t rely on it silently doing nothing.

This is the foundation

OxiRS rides on SciRS2 (scirs2-core 0.6.4) for graph analytics and numerics, routes compression through the OxiARC family (0.3.6, including a new Pure-Rust oxiarc-bzip2), handles crypto and transport through OxiCrypto/OxiTLS (0.2.1), and leans on OxiSQL (oxisql-core/oxisql-sqlite-compat 0.4.0) for its SQLite-compatible GeoSPARQL backend. Alongside siblings like OxiZ (SMT) and OxiRAG, OxiRS gives you an end-to-end auditable, JVM-free, C-free path from bytes on disk to a reasoned SPARQL answer — one that a 308-finding audit just checked doesn’t cut corners you can’t see.

Repository: https://github.com/cool-japan/oxirs

Star the repo if you want a knowledge graph where “authenticated,” “durable,” and “passing conformance” all mean what they say. The era of RDF stores that fabricate conformance results and auth layers that fail open is over. Pure Rust Semantic Web is here — audited, fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ July 29, 2026