For over two decades, client-side code protection has relied on lexical cosmetic tricks: renaming variables to alphanumeric hex codes like _0x4a2b, base64-encoding string literals, and wrapping control flows in simple switch statements.
While these techniques slow down casual inspection in browser developer tools, modern static semantic graph extractors (like morluto/rea), native decompilers (NSA Ghidra, WABT wasm-decompile), and autonomous AI coding agents slice through them in seconds. An LLM or automated decompiler does not care what a variable is named: it traces the data-flow graph, reconstructs the call hierarchy, and extracts clean, readable source logic.
Today, we are proud to announce the public release of Syferit v1.0.2, the open-core multi-target code defense engine built by Soltrix Studios.
- Syferit on Soltrix Studios: https://soltrixstudios.com/apps/syferit
- Official Engine Portal & Documentation: https://syferit.soltrixstudios.com
- GitHub Repository (v1.0.2): https://github.com/soltrix-studios/syferit
Why Lexical Obfuscation Fails Against AI Agents
When an automated reverse-engineering agent analyzes a software target, it does not read code like a human browsing a text editor. It follows three deterministic phases:
- Literal & Constant Harvesting: Extracting string tables, API endpoints, encryption keys, and numeric thresholds from AST literal nodes or bytecode
co_consts. - Semantic Graph Resolution: Mapping call flows, tracking property accesses, and establishing data-flow relationships between modules.
- Symbolic SMT Simplification: Using algebraic reduction rules to collapse dead branches and isolate the underlying conditional checks.
If a transformation is algebraically invertible, an automated solver will invert it. To protect proprietary algorithms, licensing gates, and intellectual property, code defense must move to the abstract syntax tree and bytecode compilation layers.
The Four Foundations of Syferit
Syferit approaches code defense through mathematical non-invertibility and execution graph virtualization:
1. Non-Invertible Algebraic Invariants
Instead of evaluating naked scalar comparisons (such as if (input === secret)), Syferit lowers conditionals into 32-bit FNV-1a modular multiplication chains (Math.imul). Branching decisions are coupled to modular residue invariants that are only satisfied when the runtime state equals an exact algebraic target.
2. WebAssembly Mixed Boolean-Arithmetic (MBA) & Frame Expansion
Compiled WebAssembly binaries are hardened by @syferit/wasm. Scalar comparisons are transformed into multi-instruction polynomial MBA expressions, local register frames are expanded with decoy state trackers (local i32 x 6), and execution is partitioned across coupled functions in the WASM function table.
3. Adversarial Synthesis Disruption
Syferit actively defends against LLM-driven decompilers by generating identical AST and Control Flow Graph (CFG) SHA-256 hash fingerprints across distinct state-machine functions. When agents like morluto/rea attempt to build a semantic graph, their extractors collapse under hundreds of unresolved unknowns.
4. Execution Graph Virtualization
Predictable call hierarchies are flattened into cyclic state-machine dispatchers. Static call paths are completely erased, replacing predictable subroutine calls with indirect dynamic dispatch.
Verifiable Telemetry Receipts
We believe in zero-trust verification. When testing the Syferit-hardened challenge bundle with standard industry tools:
-
morluto/rea(Static Semantic Graph Analyzer):evidence_id: "ev_e944fd12a1d8fd7b45afb4ff7ef2be85eea9262dcf32b8d000ccfee8a06cca29"semantic_graph.coverage.status: "unknown"788 unresolved unknowns across 2,722 nodes and 2,387 relations0/6 application constants recovered (6/6 recovered literals are injected compliance notices) -
WABT 1.0.42(wasm-objdump/wasm-decompile):0 plaintext constants or target residues recovered from binary sections or decompiled C pseudocode -
Performance Impact:
< 0.08ms execution overhead on hot paths100.0% functional equivalence across 26 institutional test vectors0.00 INP Core Web Vitals penalty
Tested by Elite Reverse Engineers: SYFER-DEFENDER
To validate Syferit in the open, we created and submitted SYFER-DEFENDER: The Three-Layer Override, an interactive 60 FPS browser arcade shooter and 3-layer cryptographic crackme, to Crackmes.one.
The moderation team accepted the challenge with an official difficulty rating of 5. Very Hard (500 Points). Within 24 hours of release, elite reverse engineers on Crackmes.one downloaded the bundle, reversed the modular arithmetic, and submitted the first verified solutions.
- Play the Live Browser Challenge: https://syferit.soltrixstudios.com/challenge
- Download the Offline Crackme Bundle: https://syferit.soltrixstudios.com/challenge/syferit-defender-crackme.zip
Integration Across 10 Packages in 60 Seconds
Syferit is structured as an open-core monorepo spanning 10 packages available on npm, including drop-in plugins for modern frameworks:
# Harden a single bundle with the CLI
npx @syferit/cli harden ./src/app.js -o ./dist/app.protected.js
Or integrate directly into Next.js (next.config.mjs):
import { withSyferit } from "@syferit/next";
export default withSyferit({
reactStrictMode: true,
});
Syferit is available today on GitHub and npm. Explore the full documentation, play the live crackme, or inspect the technical specification at syferit.soltrixstudios.com.
