Concentrator v3.0: GPU Accelerated Hashcat Rule Processor & Generator

New in v3.0 - Advanced Filtering & Processing

🚀 Enhanced Processing Modes

Four Processing Modes
Extraction, Combinatorial, Markov, and Interactive Processing

Advanced Filtering
Comprehensive rule filtering with multiple criteria

Functional Minimization
Remove functionally redundant rules using hashcat engine simulation

Levenshtein Filtering
Remove similar rules by edit distance

💾 Enhanced System Features

Pareto Analysis
Statistical analysis with curve visualization

Hashcat Rule Cleanup
CPU/GPU compatibility validation

Memory Safety Decorators
Automatic memory usage monitoring

Enhanced Interactive Mode
Comprehensive filtering options

v3.0 Performance & Feature Improvements

Extraction Mode: Enhanced GPU validation
Combinatorial Mode: 5-20x faster with GPU
Markov Mode: Statistical generation with validation
Processing Mode: Interactive rule minimization
Filtering: Multiple advanced filtering options

Memory Management: Enhanced safety decorators
User Experience: Comprehensive interactive mode
Output Quality: Better formatted and validated rules
Analysis Tools: Pareto curves and statistical insights

Four Processing Modes - Complete Feature Breakdown

Extraction Mode (-e)

• Extract top existing rules

• Frequency or statistical sort

• GPU-accelerated validation

• Multi-core file analysis

concentrator.py rules/ -e -t 10000

Primary: CPU | Validation: GPU Enhanced

Combinatorial Mode (-g)

• Generate new rules combinatorially

• GPU-accelerated generation

• Built-in syntax validation

• Target-based operator selection

concentrator.py rules/ -g -n 100000 -l 1 3

Primary: GPU | Fallback: CPU

Markov Mode (-gm)

• Statistical rule generation

• Probability-based sequences

• Context-aware generation

• Optional GPU validation

concentrator.py rules/ -gm -gt 10000 -ml 1 5

Primary: CPU | Validation: GPU Optional

Processing Mode (-p)

• Interactive rule minimization

• Advanced filtering options

• Functional redundancy removal

• Comprehensive analysis tools

concentrator.py rules/ -p -d

Interactive | Multi-filter | Analysis

Advanced Filtering & Optimization Options

🔄 Functional Minimization

Hashcat Engine Simulation
Actual rule effect testing

Remove Redundant Rules
Same output = removed

Test Vector Based
Multiple test passwords

RAM Intensive
Warnings for large datasets

📏 Levenshtein Filtering

Edit Distance Based
Remove similar rules

Configurable Threshold
1-10 character distance

Similarity Detection
Structural rule comparison

Performance Optimized
Smart comparison algorithms

⚡ Hashcat Cleanup

CPU/GPU Compatibility
Mode-specific validation

Official Hashcat Standards
Based on cleanup-rules.c

Syntax Validation
Proper operator usage

Rule Length Limits
255 rules per line enforcement

📊 Statistical Filtering

Pareto Analysis
80/20 rule optimization

Occurrence Based
Minimum count threshold

Top-N Selection
Keep best performing rules

Inverse Mode
Keep rules below cutoff

💾 Memory Management

Safety Decorators
Automatic memory checks

RAM Monitoring
Real-time usage tracking

Swap Detection
Automatic fallback warnings

Process Isolation
Multi-core optimization

🎯 Interactive Mode

Guided Processing
Step-by-step filtering

Real-time Analysis
Immediate feedback

Visual Progress
Colorized output

Save Points
Multiple export options

GPU Acceleration: What's Actually Accelerated

✅ GPU Accelerated

Combinatorial Generation
Full GPU rule creation with validation

Batch Rule Validation
Mass parallel syntax checking

Enhanced Extraction Validation
GPU validation for extracted rules

OpenCL Kernels
Custom GPU code for rule processing

❌ CPU Only

Markov Generation
Statistical rule creation

File Analysis
Rule extraction and counting

Model Building
Markov probability calculations

Interactive Mode Logic
User interface processing

🔄 Hybrid Processing

Markov Validation
GPU validation after CPU generation

Extraction Mode
CPU analysis + GPU validation

Interactive Mode
CPU UI with GPU backend

Fallback System
GPU → CPU on error

Performance Reality Check

Combinatorial Mode: 5-20x faster with GPU
Markov Mode: No GPU acceleration for generation
Validation: 10-100x faster with GPU
Extraction: CPU analysis + GPU validation

Best for GPU: Mass rule generation & validation
Best for CPU: Statistical analysis & file I/O
Hybrid Benefit: Validation across all modes
Fallback: Seamless CPU operation

Interactive Processing Workflow

Interactive Menu Options

(1) Minimum Occurrence: Filter by count threshold

(2) Maximum Rules: Keep top N rules only

(3) Functional Minimization: Remove redundant rules

(4) Inverse Mode: Keep rules below cutoff

(5) Hashcat Cleanup: CPU/GPU compatibility

(6) Levenshtein Filter: Remove similar rules

Analysis & Utilities

(p) Pareto Analysis: Statistical distribution curves

(s) Save: Multiple export formats

(r) Reset: Restore original dataset

(i) Info: Dataset statistics

(q) Quit: Exit with save options

Interactive Session Example

🎯 ENHANCED RULE PROCESSING - INTERACTIVE MENU

📊 Initial dataset: 45,321 unique rules

✅ Applying functional minimization...

⚡ Removed 12,456 functionally redundant rules

✅ Applying Levenshtein filtering...

📏 Removed 3,210 similar rules (max distance: 2)

📈 Final count: 29,655 unique rules (34.5% reduction)

💾 Rules saved to: concentrator_processed_29655rules.rule

Command Line Usage & Examples

Basic Usage

# Interactive mode (no arguments)

python concentrator.py

# Show help

python concentrator.py -h

Extraction Mode Examples

# Extract top 5000 rules

python concentrator.py -e -t 5000 rules/

# Statistical sort with GPU

python concentrator.py -e -t 10000 -s rules/

Generation Mode Examples

# Generate 50k combinatorial rules

python concentrator.py -g -n 50000 -l 2 4 rules/

# Markov generation

python concentrator.py -gm -gt 10000 -ml 1 5 rules/

Processing Mode Examples

# Interactive processing with disk

python concentrator.py -p -d rules/

# With Levenshtein filtering

python concentrator.py -p -ld 3 rules/

Performance Optimizations & System Features

🚀 GPU Acceleration

OpenCL-powered parallel processing for combinatorial generation and batch validation

⚡ Multi-Core Processing

Parallel file analysis and rule generation using all available CPU cores

💾 Smart Memory Management

Real-time RAM monitoring with safety decorators and swap detection

🎯 Hybrid Architecture

Smart task distribution - GPU for parallel tasks, CPU for sequential algorithms

🛡️ Error Recovery

Graceful fallbacks with automatic GPU → CPU failover on errors

📈 Progress Tracking

Real-time progress bars and colorized status updates for all operations

🔧 Temp File Management

Automatic cleanup with disk-based fallback for memory-intensive operations

🎨 Colorized Output

Visual feedback with emoji indicators and color-coded status messages