RANKER v3.3

⚡ ULTRA-OPTIMIZED GPU ARCHITECTURE

Complete Python Implementation - Simplified Loading & Enhanced Performance

Pure Python GPU-Optimized Double Buffering Production Ready

🚀 Complete Python Implementation

Python

Pure Python Script

No external dependencies

PyOpenCL

GPU Acceleration

Cross-platform support

25k+

words/second

Optimized throughput

📦 Simplified Architecture

Removed memory-mapped file complexity. Uses simple but fast batch loading with optimized memory management

✓ Simplified wordlist loader

✓ Optimized batch processing

✓ Reduced complexity

✓ Better error handling

🔄 Enhanced Processing Flow

Processes all rule batches against each word batch with proper double buffering and optimized GPU utilization

✓ All rules per word batch

✓ Double buffering support

✓ Continuous GPU pipeline

✓ Memory-optimized batches

📋 Complete Command Line Interface

# Basic usage with required arguments:
python ranker.py -w wordlist.txt -r rules.rule -c cracked.txt -o output.csv

# Use performance presets:
python ranker.py -w wordlist.txt -r rules.rule -c cracked.txt \
  --preset aggressive --output results.csv

# Save top 5000 rules with benchmarking:
python ranker.py -w rockyou.txt -r best64.rule -c cracked.txt \
  -k 5000 --benchmark-mode --target-device "RTX 4090"

# List available presets:
python ranker.py --list-presets

Required Arguments:

  • • -w, --wordlist: Base wordlist file
  • • -r, --rules: Hashcat rules file
  • • -c, --cracked: Cracked passwords file
  • • -o, --output: Output CSV file

Advanced Options:

  • • -k, --topk: Top rules to save (default: 1000)
  • • --preset: Performance preset
  • • --target-device: Target specific GPU
  • • --benchmark-mode: Detailed performance metrics
  • • --disable-progress-bars: Clean output mode

✨ Key Features & Improvements

📦 Simplified Loading

Removed complex memory-mapped file processing. Uses simple but efficient batch loading that reads entire wordlist at once for maximum speed.

✓ Fast file reading

✓ Reduced complexity

✓ Better error handling

⚡ GPU Optimization

Enhanced GPU buffer management with double buffering support. Optimized kernel compilation with NVIDIA-specific optimizations.

✓ Double buffering

✓ Memory pooling

✓ Compile optimizations

🔄 Batch Processing

New architecture processes all rule batches against each word batch. Proper progress tracking and statistics across all batches.

✓ All rules per batch

✓ Continuous processing

✓ Progress tracking

🔄 Enhanced Processing Architecture

1️⃣

Load Word Batch

Read entire wordlist and split into optimized batches

2️⃣

Precompute Rules

Encode all rules into GPU-friendly format in parallel

3️⃣

Process All Rules

Apply all rule batches to current word batch on GPU

4️⃣

Accumulate Scores

Collect statistics and move to next word batch

# Simplified processing flow:
for word_batch in all_word_batches:
  for rule_batch in all_rule_batches:
    # Process rule batch against current word batch
    process_gpu_batch(word_batch, rule_batch)
  # Update progress and statistics
  update_progress_and_scores()

🎯 Intelligent Performance Presets

Preset GPU VRAM Batch Size Global Bits Cracked Bits Performance Use Case
low_memory < 4GB 50,000 30 28 ~15k words/s Entry-level GPUs
medium_memory 4-8GB 150,000 33 31 ~21k words/s Mid-range GPUs
high_memory > 8GB 300,000 35 33 ~25k words/s High-end GPUs
aggressive > 12GB 400,000 37 35 ~30k words/s Maximum performance
balanced 6-10GB 200,000 34 32 ~22k words/s Recommended default

Command Examples with Presets

# Use balanced preset (recommended):
python ranker.py -w wordlist.txt -r rules.rule -c cracked.txt \
  --preset balanced -o results.csv

# Maximum performance on high-end GPU:
python ranker.py -w rockyou.txt -r 500k.rule -c cracked.txt \
  --preset aggressive --target-device "RTX 4090"

# Memory-constrained system:
python ranker.py -w wordlist.txt -r rules.rule -c cracked.txt \
  --preset low_memory --disable-progress-bars

💡 Practical Usage Examples

Example 1: Complete Rule Analysis

# Analyze all rules with optimized settings
python ranker.py \
  -w rockyou.txt \
  -r best64.rule \
  -c cracked_passwords.txt \
  -o best64_analysis.csv \
  --preset balanced \
  -k 1000

This processes the entire RockYou wordlist against all Best64 rules, scores each rule based on uniqueness and effectiveness, and saves the top 1000 rules to an optimized .rule file.

Example 2: Large Rule Set Optimization

# Process 500k rules with benchmarking
python ranker.py \
  -w company_wordlist.txt \
  -r 500k_rules.rule \
  -c company_cracks.txt \
  -o company_optimized.csv \
  -k 5000 \
  --preset high_memory \
  --benchmark-mode

Process a large 500k rule set against company-specific data with detailed performance metrics. Saves the top 5000 most effective rules for targeted campaigns.

Example 3: Targeted GPU Optimization

# Target specific GPU with custom settings
python ranker.py \
  -w wordlist.txt \
  -r custom_rules.rule \
  -c cracked_hashes.txt \
  -o optimized_rules.csv \
  --target-device "RTX 3080" \
  --batch-size 250000 \
  --global-bits 34 \
  --cracked-bits 32

Custom configuration for specific hardware. Manual tuning of batch sizes and hash map parameters for optimal performance on RTX 3080.

🔧 Technical Implementation

Simplified Wordlist Loader

def simplified_wordlist_loader(wordlist_path):
  with open(wordlist_path, 'rb') as f:
    content = f.read() # Read entire file
  lines = content.split(b'\\n')
  for i in range(0, len(lines), batch_size):
    batch_lines = lines[i:i+batch_size]
    yield process_batch(batch_lines)

Simple but efficient batch loading that reads the entire wordlist at once for maximum I/O performance, then processes in memory-optimized batches.

GPU Buffer Management

# Double buffering for continuous pipeline
buffers = {}
for i in range(2):
  buffers[f'base_words_in_{i}'] = cl.Buffer(...)
  buffers[f'base_hashes_{i}'] = cl.Buffer(...)

# Optimized kernel compilation
compile_options = [
  "-cl-fast-relaxed-math",
  "-cl-mad-enable",
  "-cl-no-signed-zeros"
]

Advanced GPU buffer management with double buffering support and optimized kernel compilation flags for maximum performance.

Enhanced Features

Performance Monitoring

  • • Real-time throughput display
  • • GPU utilization tracking
  • • Batch speed statistics
  • • Memory usage monitoring

Optimization Flags

  • • --disable-progress-bars
  • • --benchmark-mode
  • • --skip-rule-encoding
  • • --disable-double-buffering

GPU Selection

  • • --target-device
  • • --force-nvidia
  • • --force-amd
  • • Auto-detection

🔗 Integration & Workflow

Complete Password Cracking Optimization Workflow

  1. 1

    Collect Previous Cracking Data

    Extract cracked passwords from hashcat sessions into cracked.txt

  2. 2

    Run RANKER v3.3 Analysis

    python ranker.py -w wordlist.txt -r all_rules.rule -c cracked.txt --preset balanced
  3. 3

    Generate Optimized Rules

    Produces optimized.rule file with most effective rules for your data

  4. 4

    Deploy in Hashcat

    hashcat -m 0 hashes.txt wordlist.txt -r optimized.rule

Output Files

✓ output.csv - Complete ranking with scores

✓ output_optimized.rule - Top rules in Hashcat format

✓ Detailed statistics and performance metrics

✓ Command-line progress and summary

Automation Ready

✓ Command-line interface for scripting

✓ Exit codes for success/failure

✓ Progress tracking for monitoring

✓ Standard output formats

RANKER v3.3 - COMPLETE PYTHON IMPLEMENTATION

Pure Python • GPU-Optimized • Simplified Architecture • Production Ready