GitHub - ron7/passmut: password mutation engine

A powerful, high-performance password mutation and wordlist generation tool written in Go. Transform simple wordlists into comprehensive password dictionaries for security testing, password auditing, and penetration testing.

Features

High Performance: Multi-threaded processing using goroutines for fast wordlist generation
Comprehensive Mutations: Generate all case permutations, leet speak variations, reversals, and more
Flexible Input: Support for multiple input files, glob patterns, and stdin
Smart Filtering: Length constraints, pattern matching (crunch-style masks), strength scoring, and exclusion lists
Passphrase Generation: Create random passphrase combinations from input words
Statistical Analysis: Analyze wordlists with detailed statistics and charts
Efficacy Sorting: Sort by password effectiveness using RockYou-derived weights
Duplicate Prevention: Automatic deduplication using CRC32 checksums
Custom Rules: Define custom transformation sequences

Installation

From Source

git clone https://github.com/ron7/passmut.git
cd passmut
go build -o passmut main.go

Using Make

make build        # Production build (optimized)
make build-dev    # Development build
make install      # Install to GOPATH/bin

Binary Releases

Download pre-built binaries from the Releases page.

Quick Start

# Basic usage - mutate a wordlist
passmut --file wordlist.txt

# Pipe input from stdin
cat wordlist.txt | passmut

# Save to file
passmut --file wordlist.txt --output mutated.txt

# Analyze a wordlist
passmut --file wordlist.txt --analyze

Usage Examples

Basic Mutations

# Capitalize first letter
passmut --file words.txt --capital

# Convert to uppercase
passmut --file words.txt --upper

# Reverse words
passmut --file words.txt --reverse

# Simple leet speak (password -> p@ssw0rd)
passmut --file words.txt --leet

# Full leet variations (all combinations)
passmut --file words.txt --full-leet

# All case permutations (warning: huge output!)
passmut --file words.txt --all-cases

Advanced Mutations

# Add years (1980-current) to start and end
passmut --file words.txt --years

# Add custom prefix strings
passmut --file words.txt --prefix-strings "admin,test,user"

# Add number range suffix (0-99)
passmut --file words.txt --suffix-range "0-99"

# Add punctuation
passmut --file words.txt --punctuation

# Double each word
passmut --file words.txt --double

Permutations and Combinations

# Generate all permutations of words
passmut --file words.txt --perms

# Generate passphrases (3 words)
passmut --file words.txt --passphrase 3

# Custom separator for passphrases
passmut --file words.txt --passphrase 3 --sep "_"

Filtering and Constraints

# Filter by length (min 8, max 12)
passmut --file words.txt --min 8 --max 12

# Crunch-style mask filter (5 chars ending in digit)
passmut --file words.txt --crunch "....#"

# Filter by strength score (0-4)
passmut --file words.txt --min-strength 3

# Exclude words with numbers
passmut --file words.txt --no-numbers

# Exclude words with symbols
passmut --file words.txt --no-symbols

# Exclude words with capitals
passmut --file words.txt --no-capitals

# Exclude common passwords
passmut --file words.txt --exclude-common common-passwords.txt

Sorting and Prioritization

# Alphabetical sort
passmut --file words.txt --sort a

# Efficacy sort (common patterns first)
passmut --file words.txt --sort e

Custom Rules

# Apply custom transformation sequence
passmut --file words.txt --rules "-r,--upper,-t"
# This reverses, uppercases, then applies leet

Multiple Input Files

# Multiple files
passmut --file "file1.txt,file2.txt,file3.txt"

# Using glob patterns
passmut --file "wordlists/*.txt"

# Mix files and stdin
passmut --file "common.txt,-"  # Reads common.txt and stdin

Analysis Mode

# Analyze wordlist statistics
passmut --file rockyou.txt --analyze

Performance Tuning

# Use 8 threads
passmut --file words.txt --threads 8

# Default is CPU core count
passmut --file words.txt

Command-Line Options

Core Options

Flag	Long Form	Description
`-h`	`--help`	Show help (`-hl` for long help)
`-f`	`--file`	Input file(s), use commas for list
`-o`	`--output`	Output file (default: stdout)
`-v`		Show version

Text Manipulation (Simple)

Flag	Long Form	Description
`-a`	`--analyze`	Analyze input wordlist(s) and show statistics
`-A`	`--acronym`	Create acronyms from input words
`-ac`	`--all-cases`	Generate all case permutations (warning: huge output)
`-c`	`--capital`	Capitalize first letter
`-d`	`--double`	Double each word
`-l`	`--lower`	Convert to lowercase
`-r`	`--reverse`	Reverse the word
`-s`	`--swap`	Swap case (toggle)
`-t`	`--leet`	Simple leet speak replacement
`-T`	`--full-leet`	All recursive leet combinations
`-u`	`--upper`	Convert to uppercase

Text Manipulation (Append/Prepend)

Flag	Long Form	Description
`-C`	`--common`	Add common words (built-in or from file)
`-ps`	`--prefix-strings`	Add comma-separated strings to start
`-ss`	`--suffix-strings`	Add comma-separated strings to end
`-pr`	`--prefix-range`	Add number range to beginning (e.g., 0-99)
`-sr`	`--suffix-range`	Add number range to end (e.g., 0-99)
`-y`	`--years`	Add year ranges (1980-current)
	`--punctuation`	Append common punctuation (!@$%^&*())
	`--space`	Add spaces between words (for permutations)

Filters & Constraints

Flag	Long Form	Description
`-m`	`--min`	Minimum word length
`-x`	`--max`	Maximum word length
`-cr`	`--crunch`	Crunch-style mask filter (e.g., `....#`)
`-ms`	`--min-strength`	Minimum strength score (0-4)
	`--exclude-common`	File containing passwords to exclude
	`--no-numbers`	Exclude words with numbers
	`--no-symbols`	Exclude words with symbols
	`--no-capitals`	Exclude words with capitals

Advanced Features

Flag	Long Form	Description
`-p`	`--perms`	Generate all permutations of words
`-pp`	`--passphrase`	Generate passphrases of N words
`-L`	`--level`	Mutation complexity level (0-2)
`-S`	`--sort`	Sort mode: `a` (alpha) or `e` (efficacy)
`-n`	`--threads`	Number of goroutines (default: CPU cores)
	`--rules`	Custom transformation recipe (comma-separated)
	`--sep`	Separator for passphrases (default: `-`)

Maintenance

Flag	Long Form	Description
	`--check-updates`	Check GitHub for newer version
	`--upgrade`	Perform self-upgrade

Crunch-Style Mask Filter

The --crunch option uses a mask pattern similar to the crunch tool:

. - Any character
# - Digit (0-9)
^ - Uppercase letter (A-Z)
% - Lowercase letter (a-z)
& - Special character

Examples:

# 5 characters ending in a digit
passmut --file words.txt --crunch "....#"

# 8 characters: uppercase, 6 any, digit
passmut --file words.txt --crunch "^......#"

Mutation Levels

The --level option controls mutation complexity:

Level 0 (default): Apply mutations once
Level 1: Apply mutations with chaining
Level 2: Apply mutations recursively (all combinations)

Strength Scoring

The --min-strength filter uses a 0-4 scoring system:

0: Weak (short, simple patterns)
1: Fair (basic complexity)
2: Good (moderate complexity)
3: Strong (high complexity)
4: Supreme (maximum complexity)

Scoring considers:

Character variety (lowercase, uppercase, numbers, symbols)
Length (bonus for 12+ characters, penalty for <8)
Pattern complexity

Examples

Example 1: Basic Password Mutations

# Input: wordlist.txt contains "password"
passmut --file wordlist.txt --capital --leet --years

# Output includes:
# Password
# Password2024
# Password2023
# ...
# P@ssw0rd
# P@ssw0rd2024
# ...

Example 2: Comprehensive Attack Wordlist

passmut --file company-names.txt \
  --capital \
  --leet \
  --years \
  --suffix-range "0-999" \
  --punctuation \
  --min 8 \
  --max 16 \
  --output attack-wordlist.txt

Example 3: Passphrase Generation

# Generate 3-word passphrases with underscore separator
passmut --file words.txt --passphrase 3 --sep "_"

# Output examples:
# word1_word2_word3
# test_admin_password
# ...

Example 4: Filtered Wordlist

# Only 8-12 character passwords with numbers and capitals
passmut --file words.txt \
  --min 8 \
  --max 12 \
  --no-numbers false \
  --no-capitals false \
  --min-strength 2

Performance Tips

Use appropriate thread count: Default uses CPU cores, increase for I/O-bound operations
Filter early: Use --min/--max to reduce processing
Avoid --all-cases on large lists: Generates 2^N variations per word
Use --exclude-common: Remove known weak passwords early
Output to file: Avoid stdout for large outputs

Limitations

Memory: Large wordlists with extensive mutations can consume significant memory
All Cases: The --all-cases option generates 2^N variations (e.g., 10-char word = 1024 variations)
Permutations: The --perms option can generate factorial combinations

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Fork the repository
Create your feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'Add some AmazingFeature')
Push to the branch (git push origin feature/AmazingFeature)
Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Disclaimer

This tool is intended for authorized security testing, password auditing, and educational purposes only. Users are responsible for ensuring they have proper authorization before using this tool on any system or network.

Acknowledgments

Inspired by password mutation tools in the security community
Uses RockYou-derived efficacy weights for password sorting

Version

Current version: 0.4

Check for updates: