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.
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
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.