Unified Hashcat Rule Processor

Concentrator v3.4

Extract, generate, and process Hashcat rules with GPU acceleration, Markov chain modeling, functional minimization, and Levenshtein deduplication.

OpenCL GPU Markov Models Interactive & CLI Modes Combinatorial Gen Functional Minimization Levenshtein Filter Memory Safety
Overview

Concentrator v3.4 is a unified Hashcat rule processor — extract the most effective rules from existing rulesets, generate new ones combinatorially or via Markov models, and minimize/deduplicate any collection with GPU-backed functional equivalence checking.

Unlike static rule lists, Concentrator adapts to your data. Four operating modes cover every stage of a rule ruleflow: extraction from corpora, combinatorial chain generation, Markov-based statistical generation, and interactive deduplication with Levenshtein near-duplicate filtering. All optional dependencies degrade gracefully — the tool runs on pure Python if needed.

Core Features
⚡
OpenCL GPU acceleration
Batch rule validation offloaded to GPU for high throughput. Falls back to CPU automatically if unavailable.
~
Three generation modes
Extraction (-e), combinatorial generation (-g), and Markov-based generation (-gm).
∑
Functional minimization
Deduplicate rules that produce identical outputs via signature-based equivalence checking.
≈
Levenshtein distance filtering
Remove near-duplicate rules by edit distance (configurable max distance).
🛡
Memory safety
Monitors RAM/swap usage with configurable thresholds and disk-spill mode to avoid OOM conditions.
⤳
Interactive & CLI modes
Guided wizard via python concentrator.py or full argument-driven CLI with one required mode flag.
Operating Modes
-e
Extraction mode (--extract-rules)
Extract the most frequent or statistically weighted rules from existing rule files. Supports -t (top N) and -s (Markov-probability sort).
-g
Combinatorial mode (--generate-combo)
Exhaustively combine the most common operators up to a target count. Configure with -n (target count) and -l min max (chain length).
-gm
Markov mode (--generate-markov-rules)
Generate statistically probable rules using a Markov chain model trained on the input rule files. Configure with -gt and -ml min max.
-p
Processing mode (--process-rules)
Load, validate, deduplicate, and functionally minimize existing rule sets. Supports -d (disk spill) and -ld N (Levenshtein max distance).
Installation & Requirements

Python 3.8+. All optional packages degrade gracefully — the tool runs on pure Python if none are installed.

# Clone the repository git clone https://github.com/A113L/concentrator.git cd concentrator # Install optional dependencies (recommended) pip install pyopencl numpy tqdm psutil
Optional packages:
pyopencl — GPU-accelerated rule validation  ·  numpy — GPU array operations  ·  tqdm — progress bars  ·  psutil — RAM/swap monitoring
Usage Examples
# Extract top 5000 rules by frequency python concentrator.py -e -t 5000 rules/ # Generate 100k combinatorial rules (expanded format) python concentrator.py -g -n 100000 -l 1 3 -f expanded hashcat/rules/ # Markov generation, length 2–4 python concentrator.py -gm -gt 20000 -ml 2 4 hashcat/rules/ # Process + minimize with disk spill and Levenshtein filter python concentrator.py -p -d -ld 3 rules/ # Interactive wizard python concentrator.py
Get the Source

Concentrator is open source and hosted on GitHub. MIT licensed.

View concentrator on GitHub