Overview Toolchain Architecture Security Install & Run
RULEOPS · UNIFIED LOCAL WEB WORKBENCH

RULEOPS

One local web interface for the whole A1131 rule‑extraction stack — Rulest, Rule Ranker and Concentrator — with live progress, a reusable asset library and a built‑in GPU diagnostics panel. Run it on your own box, log in, and drive every tool from one dashboard.

Local‑only Server Session Auth + CSRF Unified Dashboard Reusable Asset Library Live Progress & Logs GPU Diagnostics SQLite‑backed Security Pause / Resume Runs
Overview

RULEOPS is a single app.py HTTP server that wraps Rulest, Rule Ranker and Concentrator behind one authenticated web UI, so you don't juggle four terminals and a pile of CLI flags.

Upload a base/target wordlist pair (or a cracked‑password wordlist for ranking, or a batch of rule files for concentration), pick a tool and its parameters, and start a run. RULEOPS streams stage names, progress counters and log lines back to the browser in real time, and lets you pause, resume or stop a running job.

Everything that gets uploaded — wordlists and rule files — lands in a reusable library on disk, so the next run can reference an existing asset instead of re‑uploading it.

Core Features
🖥
Single local dashboard
Drive Rulest, Ranker and Concentrator from one page instead of separate CLI invocations.
🔐
Password auth, hashed & salted
600,000‑iteration PBKDF2 sessions, in‑memory tokens that die on server restart, SQLite‑backed lockout after repeated failures.
📈
Live stage & progress streaming
Current stage, completed/total counters, rate and running logs update in the browser without a page reload.
📚
Reusable wordlist & rule library
Uploaded wordlists and rule files are retained and categorized; CSVs stay run‑scoped and are cleaned up automatically.
⏸
Pause / resume / stop
Long GPU runs can be paused and resumed from the UI without losing extraction state.
🩺
Built‑in GPU diagnostics
Surfaces OpenCL device discovery output directly in the dashboard before you start a job.
📦
Run manifests & output bundling
Each run writes a manifest describing its inputs and outputs; results can be downloaded as a zip.
🧹
Storage intelligence
Session‑scoped scan & cleanup helper for old runs and uploads, with a history of what it found and removed.
Request lifecycle
Step 1
Sign in
PBKDF2‑backed login creates a session token and CSRF cookie; failed attempts are rate‑limited and lock out per the SQLite‑backed login‑failure table.
Step 2
Pick a tool
Choose Rulest (base/target/seed), Ranker (wordlist/cracked/rules + CSVs) or Concentrator (batch rule files, up to 32 / 40 GB).
Step 3
Upload or reuse assets
New files are reserved and streamed to runs/uploads; previously uploaded wordlists/rules can be pulled straight from the library instead.
Step 4
Run & monitor
The job runs as a managed subprocess; the dashboard polls stage, progress and log state and exposes pause/resume/stop controls.
Step 5
Collect outputs
Finished runs register their output files in the run manifest, ready to download or feed into the next tool in the chain.
Toolchain Integration — All RULEOPS Tools

RULEOPS brings together six complementary tools for generating, ranking and compressing Hashcat rule sets — five of them behind the authenticated server UI, plus one browser‑only utility.

Rulest
Four‑phase GPU rule extraction from a base/target wordlist pair, with built‑in seed families (A–M) and an optional genetic phase.
  • Base, target & optional seed uploads
  • Live progress per phase
  • Outputs a minimized .rule file
Rule Ranker
Scores a candidate rule file against a wordlist + cracked‑password sample (adaptive multi‑armed‑bandit or legacy exhaustive mode), then runs its built‑in greedy/CELF max‑coverage postprocessing pass (GPU coverage + CPU or GPU CELF) to compress the ranked candidates into a compact, high‑coverage rule file.
  • Wordlist, cracked‑list & rules uploads
  • CSV analysis inputs/outputs, GPU‑accelerated scoring
  • Built‑in CELF/greedy selection (--select-mode greedy), budget‑ & cost‑aware
Concentrator
Extracts, generates and cleans rule collections from existing material, merging and deduplicating batches of rule files (up to 32 files / 40 GB).
  • Batch upload of rule files
  • Size & count safety limits
  • Feeds Minimizer for final cleanup
Rulestripper
Empirically derives rule chains by decomposing TARGET words into BASE‑word stems and transformations, across 14 extraction modes.
  • Base/target upload, CPU‑only pass
  • 14 token‑strip extraction modes
  • Also runs as Rulest's optional Phase 0
Rule Minimizer
Removes functionally/behaviorally equivalent rules by comparing their output over a shared probe‑word set.
  • Rules + probe‑word uploads
  • Signature‑based dedup, multi‑worker
  • Typical last step of the pipeline
Email Rule Extractor
Browser‑only utility (no server round‑trip) that derives candidate rules from email‑address‑style naming patterns.

Outputs from any tool can be pushed into the library and picked up by the next. A typical pipeline looks like: Rulest / Rulestripper → Rule Ranker (score + CELF selection) → Concentrator → Rule Minimizer — all driven from this one dashboard.

⚙️ Architecture
  • Single‑process http.server.ThreadingHTTPServer — no external web framework required
  • Background subprocess per run, controlled via a run‑scoped control file and PID tracking
  • SQLite database for login security state (failures, lockouts)
  • Per‑run manifest (.ruleops-run.json) recording dataset provenance and outputs
  • GPU diagnostics collected via a dedicated gpu_diagnostics module
🔒 Security Model
  • Passwords hashed with PBKDF2, 600,000 iterations — never stored in clear text
  • Sessions are in‑memory only; a server restart signs every browser out
  • CSRF‑protected session cookies, 12‑hour TTL
  • Login attempts rate‑limited (5 failures / 5 min) with escalating lockouts up to 1 hour
  • Designed to bind to a local interface — treat it as a trusted‑network / localhost tool, not a public‑internet service
Install & Run
View repo on GitHub
Linux / macOS
# from the RULEOPS/ directory
chmod +x start_gui.sh
./start_gui.sh
# optional: set host (defaults to 0.0.0.0, port 8765)
RULEST_HOST=127.0.0.1 ./start_gui.sh
Windows
:: from the RULEOPS\ directory
start_gui.bat
💡 Tip: On first launch, set an admin password of at least 12 characters — it's hashed with PBKDF2 and never written in clear text. Because sessions are in‑memory, restarting the server signs everyone out, which is the simplest way to force re‑authentication.
📦 Requirements
Python ≥3.8 · numpy · pyopencl · tqdm
# clone & install
git clone https://github.com/A113L/RULEOPS.git
cd RULEOPS
pip install -r requirements.txt
./start_gui.sh

OpenCL 1.2+ GPU recommended for Rulest runs (NVIDIA, AMD, Intel); CPU fallback is supported but slow. Test suite under tests/ runs via pytest.

⚠️ Scope & Usage Notes

RULEOPS is a local, self‑hosted research/benchmarking workbench for the Rulest/Ranker/Concentrator toolchain — it is meant to run on a machine you control, bound to a trusted interface.

It ships no public multi‑tenant hardening beyond the login/session controls described above, so avoid exposing RULEST_HOST directly to the open internet.