advanced-wordlist-generator.py

#!/usr/bin/env python3

# =============================================================================
# Advanced Username-Based Password Wordlist Generator
# =============================================================================
#
# Description:
#   This script generates custom password wordlists using usernames,
#   emails, company names, keyboard patterns, leetspeak mutations,
#   seasonal passwords, and common password combinations.
#
# Features:
#   - Username parsing
#   - Email splitting
#   - Leetspeak mutations
#   - Reverse strings
#   - Case variations
#   - Numeric combinations
#   - Seasonal passwords
#   - Company keyword combinations
#   - Keyboard pattern combinations
#   - Password length filtering
#   - Optional gzip compression
#
# Author:
#   Rahul Jain
#
# Usage Examples:
#
#   Basic:
#       python3 advanced-wordlist-generator.py \
#       -i users.txt \
#       -o passwords.txt
#
#   With Company Name:
#       python3 advanced-wordlist-generator.py \
#       -i users.txt \
#       -o passwords.txt \
#       -c Armour
#
#   With Length Filters:
#       python3 advanced-wordlist-generator.py \
#       -i users.txt \
#       -o passwords.txt \
#       --min-length 8 \
#       --max-length 20
#
#   Compress Output:
#       python3 advanced-wordlist-generator.py \
#       -i users.txt \
#       -o passwords.txt \
#       --gzip
#
# =============================================================================

from datetime import datetime
import argparse
import re
import gzip
import os
import random


# =============================================================================
# Display Banner
# =============================================================================
def banner():

    print("=" * 70)
    print(" Advanced Username-Based Password Wordlist Generator ")
    print("=" * 70)


# =============================================================================
# Generate Leetspeak Variants
#
# Example:
#   password -> p@ssw0rd
# =============================================================================
def leetspeak(word):

    substitutions = {
        'a': ['@', '4'],
        'e': ['3'],
        'i': ['1', '!'],
        'o': ['0'],
        's': ['$', '5'],
        't': ['7'],
        'l': ['1'],
        'g': ['9']
    }

    variants = {word}

    for char, replacements in substitutions.items():

        temp = set()

        for variant in variants:

            for replacement in replacements:

                regex = re.compile(char, re.IGNORECASE)

                mutated = regex.sub(replacement, variant)

                temp.add(mutated)

        variants.update(temp)

    return variants


# =============================================================================
# Split Username / Email into Parts
#
# Example:
#   john.smith_admin@company.com
#
# Returns:
#   john
#   smith
#   admin
#   company
# =============================================================================
def split_name(name):

    separators = ['.', '_', '-', '@']

    parts = [name]

    for sep in separators:

        if sep in name:
            parts.extend(name.split(sep))

    return set(filter(None, parts))


# =============================================================================
# Generate Case Variants
#
# Example:
#   Harry
#   harry
#   HARRY
#   YrraH
# =============================================================================
def generate_case_variants(word):

    return {
        word,
        word.lower(),
        word.upper(),
        word.capitalize(),
        word.swapcase(),
        word[::-1],
        word.lower()[::-1],
        word.capitalize()[::-1]
    }


# =============================================================================
# Generate Common Numeric Patterns
#
# Example:
#   123
#   007
#   786
# =============================================================================
def generate_numeric_patterns():

    patterns = []

    for i in range(0, 100):

        patterns.append(str(i))
        patterns.append(f"{i:02}")

    patterns.extend([
        "123",
        "1234",
        "12345",
        "123456",
        "111",
        "000",
        "007",
        "786",
        "420",
        "321"
    ])

    return patterns


# =============================================================================
# Generate Special Character Patterns
#
# Example:
#   @123
#   !
#   #
# =============================================================================
def generate_special_patterns():

    return [
        "@123",
        "@1234",
        "@2024",
        "@2025",
        "@2026",
        "!",
        "@",
        "#",
        "$",
        "%",
        "&",
        "*"
    ]


# =============================================================================
# Generate Seasonal Password Patterns
#
# Example:
#   Summer2026
#   Winter2026
# =============================================================================
def generate_seasons(year):

    return [
        f"Summer{year}",
        f"Winter{year}",
        f"Spring{year}",
        f"Fall{year}",
        f"Monsoon{year}"
    ]


# =============================================================================
# Generate Keyboard-Based Password Patterns
#
# Example:
#   qwerty123
#   asdf123
# =============================================================================
def generate_keyboard_patterns():

    return [
        "qwerty",
        "qwerty123",
        "asdf123",
        "zxcvbnm",
        "admin123",
        "welcome123",
        "password123",
        "letmein123"
    ]


# =============================================================================
# Generate Smart Password Combinations
#
# Example:
#   Harry123
#   Harry@2026
#   ArmourHarry2026
# =============================================================================
def smart_combinations(base, company, years):

    combinations = set()

    numeric_patterns = generate_numeric_patterns()
    special_patterns = generate_special_patterns()

    # Numeric combinations
    for num in numeric_patterns:

        combinations.add(base + num)
        combinations.add(base + "@" + num)
        combinations.add(base + "_" + num)
        combinations.add(base + "-" + num)

    # Special character combinations
    for special in special_patterns:

        combinations.add(base + special)
        combinations.add(special + base)

    # Year combinations
    for year in years:

        combinations.add(base + year)
        combinations.add(base + "@" + year)
        combinations.add(base + year + "!")
        combinations.add(base + "_" + year)

    # Company-based combinations
    if company:

        company_variants = generate_case_variants(company)

        for comp in company_variants:

            combinations.add(comp + base)
            combinations.add(base + comp)
            combinations.add(comp + "@" + base)
            combinations.add(base + "@" + comp)

            for year in years:

                combinations.add(comp + year)
                combinations.add(comp + "@123")
                combinations.add(comp + base + year)

    return combinations


# =============================================================================
# Main Password Generation Function
# =============================================================================
def generate_passwords(
    input_file,
    output_file,
    company=None,
    min_length=4,
    max_length=32,
    sort_output=True,
    compress_output=False
):

    # Get current year
    current_year = datetime.now().year

    years = [
        str(current_year - 1),
        str(current_year),
        str(current_year + 1)
    ]

    # Store unique passwords
    generated = set()

    # Read usernames/emails from input file
    with open(input_file, 'r') as f:

        names = [line.strip() for line in f if line.strip()]

    # Process each entry
    for entry in names:

        parsed_parts = split_name(entry)

        for part in parsed_parts:

            # Generate case variations
            base_variants = generate_case_variants(part)

            # Generate leetspeak variants
            leet_variants = set()

            for variant in base_variants:
                leet_variants.update(leetspeak(variant))

            # Merge all variants
            final_variants = base_variants.union(leet_variants)

            # Generate password combinations
            for base in final_variants:

                generated.add(base)

                # Smart combinations
                generated.update(
                    smart_combinations(
                        base,
                        company,
                        years
                    )
                )

                # Double/reverse combinations
                generated.add(base + base)
                generated.add(base + base[::-1])

                # Seasonal combinations
                for season in generate_seasons(years[1]):

                    generated.add(base + season)
                    generated.add(season + base)

                # Keyboard combinations
                for pattern in generate_keyboard_patterns():

                    generated.add(base + pattern)
                    generated.add(pattern + base)

                # Symbol wrapping combinations
                symbols = ['@', '#', '$', '!']

                for symbol in symbols:

                    generated.add(symbol + base + symbol)
                    generated.add(base + symbol + base)

    # Filter passwords by length
    filtered = {
        pwd for pwd in generated
        if min_length <= len(pwd) <= max_length
    }

    # Sort output if enabled
    if sort_output:
        passwords = sorted(filtered)
    else:
        passwords = list(filtered)

    # Write passwords to output file
    with open(output_file, 'w') as f:

        for password in passwords:
            f.write(password + '\n')

    # Display statistics
    print(f"[+] Generated {len(passwords)} unique passwords")
    print(f"[+] Saved to: {output_file}")

    # Display file size
    file_size = os.path.getsize(output_file)

    print(f"[+] File size: {file_size / 1024:.2f} KB")

    # Compress output using gzip
    if compress_output:

        gzip_file = output_file + ".gz"

        with open(output_file, 'rb') as f_in:
            with gzip.open(gzip_file, 'wb') as f_out:
                f_out.writelines(f_in)

        print(f"[+] Compressed wordlist saved to: {gzip_file}")

    # Display sample passwords
    print("\n[+] Sample Passwords:\n")

    for pwd in random.sample(passwords, min(20, len(passwords))):
        print(pwd)


# =============================================================================
# Main Function
# =============================================================================
if __name__ == "__main__":

    # Display startup banner
    banner()

    # -------------------------------------------------------------------------
    # Configure Command-Line Argument Parser
    # -------------------------------------------------------------------------
    parser = argparse.ArgumentParser(
        description="Enhanced Username-Based Password Generator"
    )

    # -------------------------------------------------------------------------
    # Input File Argument (-i / --input)
    # -------------------------------------------------------------------------
    parser.add_argument(
        "-i",
        "--input",
        dest="input_file",
        required=True,
        help="Input usernames/emails file"
    )

    # -------------------------------------------------------------------------
    # Output File Argument (-o / --output)
    # -------------------------------------------------------------------------
    parser.add_argument(
        "-o",
        "--output",
        dest="output_file",
        required=True,
        help="Output password file"
    )

    # -------------------------------------------------------------------------
    # Company Keyword
    # -------------------------------------------------------------------------
    parser.add_argument(
        "-c",
        "--company",
        help="Optional company keyword"
    )

    # -------------------------------------------------------------------------
    # Minimum Password Length
    # -------------------------------------------------------------------------
    parser.add_argument(
        "--min-length",
        type=int,
        default=4,
        help="Minimum password length"
    )

    # -------------------------------------------------------------------------
    # Maximum Password Length
    # -------------------------------------------------------------------------
    parser.add_argument(
        "--max-length",
        type=int,
        default=32,
        help="Maximum password length"
    )

    # -------------------------------------------------------------------------
    # Disable Sorting
    # -------------------------------------------------------------------------
    parser.add_argument(
        "--no-sort",
        action="store_true",
        help="Disable sorting"
    )

    # -------------------------------------------------------------------------
    # Compress Output using Gzip
    # -------------------------------------------------------------------------
    parser.add_argument(
        "--gzip",
        action="store_true",
        help="Compress output using gzip"
    )

    # -------------------------------------------------------------------------
    # Parse Arguments
    # -------------------------------------------------------------------------
    args = parser.parse_args()

    # -------------------------------------------------------------------------
    # Start Password Generation
    # -------------------------------------------------------------------------
    generate_passwords(
        input_file=args.input_file,
        output_file=args.output_file,
        company=args.company,
        min_length=args.min_length,
        max_length=args.max_length,
        sort_output=not args.no_sort,
        compress_output=args.gzip
    )