pawpy-cli 1.0.0__py3-none-any.whl

pawpy/generator/gpu.py

@@ -0,0 +1,64 @@
+"""Optional GPU acceleration via CuPy.
+
+When ``cupy`` is installed and ``--gpu`` is passed, rule application
+is offloaded to the GPU for parallel execution.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import List
+
+logger = logging.getLogger("pawpy.generator.gpu")
+
+_CUPY_AVAILABLE = False
+try:
+    import cupy as cp
+
+    _CUPY_AVAILABLE = True
+except ImportError:
+    cp = None  # type: ignore[assignment]
+
+
+def is_gpu_available() -> bool:
+    """Check whether CuPy (and thus GPU acceleration) is available."""
+    return _CUPY_AVAILABLE
+
+
+def gpu_apply_rules(words: List[str], rules: List[str]) -> List[str]:
+    """Apply hashcat rules on the GPU using CuPy.
+
+    This is an experimental feature.  It encodes words and rules into
+    GPU arrays and applies character-level transformations in parallel.
+
+    Args:
+        words: List of base words.
+        rules: List of hashcat-style rule strings.
+
+    Returns:
+        List of mutated words from GPU computation.
+    """
+    if not _CUPY_AVAILABLE:
+        logger.warning("CuPy not installed. Falling back to CPU.")
+        return []
+
+    logger.info(
+        "GPU acceleration: processing %d words with %d rules", len(words), len(rules)
+    )
+
+    # For now, this is a placeholder that demonstrates the interface.
+    # A full GPU implementation would:
+    # 1. Encode all words into a fixed-width character array on GPU
+    # 2. Encode rules into operation arrays
+    # 3. Use CuPy kernels to apply rules in parallel
+    # 4. Transfer results back to CPU
+
+    # Placeholder: fall back to CPU rule application
+    from pawpy.mutations.mangle import apply_hashcat_rules
+
+    all_results = set()
+    for word in words:
+        all_results.update(apply_hashcat_rules(word, rules))
+
+    logger.info("GPU mode complete (CPU fallback): %d candidates", len(all_results))
+    return sorted(all_results)

pawpy/generator/hybrid.py

@@ -0,0 +1,99 @@
+"""Hybrid attack mode – combine base words with mask patterns.
+
+Simulates hashcat -a 6 (word + right mask) and -a 7 (left mask + word).
+"""
+
+from __future__ import annotations
+
+import logging
+import string
+from itertools import product
+from typing import List, Optional
+
+logger = logging.getLogger("pawpy.generator.hybrid")
+
+# Mask character mapping
+_MASK_MAP = {
+    "?l": string.ascii_lowercase,
+    "?u": string.ascii_uppercase,
+    "?d": string.digits,
+    "?s": "!@#$%^&*()_+-=[]{}|;':\",./<>?`~",
+    "?a": string.ascii_letters + string.digits + "!@#$%^&*()_+-=[]{}|;':\",./<>?`~",
+}
+
+
+def _parse_mask(mask: str) -> List[str]:
+    """Parse a hashcat-style mask string into a list of character sets.
+
+    Supports: ?l, ?u, ?d, ?s, ?a, and literal characters.
+    """
+    result = []
+    i = 0
+    while i < len(mask):
+        if mask[i] == "?" and i + 1 < len(mask):
+            token = mask[i : i + 2]
+            if token in _MASK_MAP:
+                result.append(_MASK_MAP[token])
+                i += 2
+                continue
+        # Literal character
+        result.append([mask[i]])
+        i += 1
+    return result
+
+
+def _expand_mask(mask_parts: List[List[str]], max_results: int = 100_000) -> List[str]:
+    """Expand a parsed mask into all possible combinations, with a safety cap."""
+    # Calculate total combinations
+    total = 1
+    for part in mask_parts:
+        total *= len(part)
+        if total > max_results:
+            logger.warning(
+                "Mask produces %d combinations (capped to %d). "
+                "Consider using a shorter mask.",
+                total,
+                max_results,
+            )
+            break
+
+    results = []
+    for combo in product(*mask_parts):
+        results.append("".join(combo))
+        if len(results) >= max_results:
+            break
+    return results
+
+
+def hybrid_generate(
+    words: List[str],
+    left_mask: Optional[str] = None,
+    right_mask: Optional[str] = None,
+) -> List[str]:
+    """Generate hybrid attack candidates.
+
+    Args:
+        words: Base word list.
+        left_mask: Hashcat-style mask to prepend (simulates -a 7).
+        right_mask: Hashcat-style mask to append (simulates -a 6).
+
+    Returns:
+        List of word+mask combinations.
+    """
+    results = []
+
+    if right_mask:
+        mask_parts = _parse_mask(right_mask)
+        mask_vals = _expand_mask(mask_parts, max_results=1_000)
+        for word in words:
+            for mv in mask_vals:
+                results.append(f"{word}{mv}")
+
+    if left_mask:
+        mask_parts = _parse_mask(left_mask)
+        mask_vals = _expand_mask(mask_parts, max_results=1_000)
+        for word in words:
+            for mv in mask_vals:
+                results.append(f"{mv}{word}")
+
+    return results

pawpy/generator/sorter.py

@@ -0,0 +1,136 @@
+"""Billion-scale external merge sort for wordlists.
+
+When the candidate set exceeds available memory, this module streams
+candidates to temporary sorted chunks and then merge-sorts them into
+the final output.
+"""
+
+from __future__ import annotations
+
+import heapq
+import logging
+import os
+import tempfile
+from typing import Generator, List
+
+logger = logging.getLogger("pawpy.generator.sorter")
+
+
+def _sort_and_write_chunk(lines: List[str], chunk_path: str) -> None:
+    """Sort a list of lines and write to a temp file."""
+    lines.sort()
+    with open(chunk_path, "w", encoding="utf-8", errors="ignore") as fh:
+        for line in lines:
+            fh.write(line + "\n")
+
+
+def external_merge_sort(
+    lines: Generator[str, None, None],
+    output_path: str,
+    memory_threshold: int = 500_000_000,
+    chunk_line_count: int = 5_000_000,
+) -> int:
+    """Sort and deduplicate a stream of lines using external merge sort.
+
+    When the in-memory buffer exceeds *memory_threshold* bytes, the buffer
+    is sorted, deduplicated, and flushed to a temporary file.  After all
+    input is consumed, the sorted chunks are merged.
+
+    Args:
+        lines: Generator yielding candidate password strings.
+        output_path: Final output file path.
+        memory_threshold: Approximate memory limit in bytes.
+        chunk_line_count: Maximum lines per sorted chunk.
+
+    Returns:
+        Number of unique lines written.
+    """
+    buffer: List[str] = []
+    chunk_files: List[str] = []
+    seen_in_buffer: set = set()
+    total_written = 0
+    est_size = 0
+
+    def flush_buffer():
+        nonlocal buffer, seen_in_buffer, est_size
+        if not buffer:
+            return
+        _, chunk_path = tempfile.mkstemp(suffix=".chunk", prefix="pawpy_")
+        _sort_and_write_chunk(buffer, chunk_path)
+        chunk_files.append(chunk_path)
+        logger.info(
+            "Flushed chunk %d: %d lines -> %s",
+            len(chunk_files),
+            len(buffer),
+            chunk_path,
+        )
+        buffer = []
+        seen_in_buffer = set()
+        est_size = 0
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        if line not in seen_in_buffer:
+            buffer.append(line)
+            seen_in_buffer.add(line)
+            est_size += len(line.encode("utf-8")) + 1
+
+            if est_size >= memory_threshold or len(buffer) >= chunk_line_count:
+                flush_buffer()
+
+    # Flush remaining buffer
+    flush_buffer()
+
+    if not chunk_files:
+        # Everything fit in memory – just write sorted output
+        buffer.sort()
+        with open(output_path, "w", encoding="utf-8") as fh:
+            prev = None
+            for line in buffer:
+                if line != prev:
+                    fh.write(line + "\n")
+                    total_written += 1
+                    prev = line
+        return total_written
+
+    # K-way merge using heapq
+    file_handles = []
+    try:
+        for path in chunk_files:
+            fh = open(path, "r", encoding="utf-8", errors="ignore")
+            first_line = fh.readline().strip()
+            if first_line:
+                file_handles.append((first_line, fh))
+
+        heapq.heapify(file_handles)
+
+        with open(output_path, "w", encoding="utf-8") as out_fh:
+            prev = None
+            while file_handles:
+                line, fh = heapq.heappop(file_handles)
+                if line != prev:
+                    out_fh.write(line + "\n")
+                    total_written += 1
+                    prev = line
+                next_line = fh.readline().strip()
+                if next_line:
+                    heapq.heappush(file_handles, (next_line, fh))
+                else:
+                    fh.close()
+    finally:
+        # Clean up temp files
+        for _, fh in file_handles:
+            try:
+                fh.close()
+            except Exception:
+                pass
+        for path in chunk_files:
+            try:
+                os.unlink(path)
+            except Exception:
+                pass
+
+    return total_written

pawpy/mutations/__init__.py

@@ -0,0 +1,20 @@
+"""Mutation engine – transforms base words into password candidates."""
+
+from pawpy.mutations.dates import date_permutations
+from pawpy.mutations.keyboard import dynamic_keyboard_walks, static_keyboard_walks
+from pawpy.mutations.leet import leet_speak
+from pawpy.mutations.mangle import apply_hashcat_rules, mangle_rules
+from pawpy.mutations.markov import generate_markov_words, train_markov
+from pawpy.mutations.templates import expand_templates
+
+__all__ = [
+    "leet_speak",
+    "date_permutations",
+    "mangle_rules",
+    "apply_hashcat_rules",
+    "static_keyboard_walks",
+    "dynamic_keyboard_walks",
+    "train_markov",
+    "generate_markov_words",
+    "expand_templates",
+]

pawpy/mutations/dates.py

@@ -0,0 +1,72 @@
+"""Date permutation engine.
+
+Takes dates in DDMMYYYY format and produces many common sub-string
+variants: day, month, year, two-digit year, reversed, and combinations.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import List, Optional
+
+
+def _parse_date(date_str: str) -> Optional[datetime]:
+    """Parse a DDMMYYYY string into a datetime.  Returns None on failure."""
+    date_str = date_str.strip()
+    if len(date_str) != 8 or not date_str.isdigit():
+        return None
+    try:
+        return datetime.strptime(date_str, "%d%m%Y")
+    except ValueError:
+        return None
+
+
+def date_permutations(date_str: str) -> List[str]:
+    """Generate date-based password fragments from a DDMMYYYY date string.
+
+    Produces: day, month, year (4-digit), year (2-digit), DDMM, MMDD,
+    DDMMYY, MMDDYY, YYYYMMDD, DD/MM/YYYY, MM/DD/YYYY, YYYY,
+    and reverse forms.
+    """
+    dt = _parse_date(date_str)
+    if dt is None:
+        return []
+
+    d = f"{dt.day:02d}"
+    m = f"{dt.month:02d}"
+    y4 = str(dt.year)
+    y2 = y4[-2:]
+
+    parts = [
+        d,
+        m,
+        y4,
+        y2,
+        f"{d}{m}",
+        f"{m}{d}",
+        f"{d}{m}{y2}",
+        f"{m}{d}{y2}",
+        f"{d}{m}{y4}",
+        f"{m}{d}{y4}",
+        f"{y4}{m}{d}",
+        f"{y4}{d}{m}",
+        f"{d}/{m}/{y4}",
+        f"{m}/{d}/{y4}",
+        f"{d}-{m}-{y4}",
+        f"{m}-{d}-{y4}",
+        f"{d}.{m}.{y4}",
+        f"{m}.{d}.{y4}",
+        y4,
+        y2,
+        f"{m}{d}",
+        f"{d}{m}",
+    ]
+
+    # Deduplicate while preserving order
+    seen = set()
+    result = []
+    for p in parts:
+        if p not in seen:
+            seen.add(p)
+            result.append(p)
+    return result

pawpy/mutations/keyboard.py

@@ -0,0 +1,99 @@
+"""Keyboard walk generator.
+
+Produces password candidates from continuous keyboard walks on QWERTY
+and other common layouts.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Set, Tuple
+
+# QWERTY keyboard adjacency map (row, col) -> set of (row, col) neighbours
+_QWERTY_LAYOUT = [
+    "`1234567890-=",
+    " qwertyuiop[]\\",
+    " asdfghjkl;'",
+    "  zxcvbnm,./",
+]
+
+# Build adjacency: each key maps to its neighbours (up to 8 directions)
+_QWERTY_POS: Dict[str, Tuple[int, int]] = {}
+_QWERTY_ADJ: Dict[str, List[str]] = {}
+
+for _r, row in enumerate(_QWERTY_LAYOUT):
+    for _c, ch in enumerate(row):
+        if ch == " ":
+            continue
+        _QWERTY_POS[ch] = (_r, _c)
+
+for _key, (_kr, _kc) in _QWERTY_POS.items():
+    neighbours = []
+    for dr in (-1, 0, 1):
+        for dc in (-1, 0, 1):
+            if dr == 0 and dc == 0:
+                continue
+            nr, nc = _kr + dr, _kc + dc
+            for other_key, (or_, oc) in _QWERTY_POS.items():
+                if or_ == nr and oc == nc:
+                    neighbours.append(other_key)
+    _QWERTY_ADJ[_key] = neighbours
+
+
+# Classic static keyboard walks
+STATIC_WALKS = [
+    "qwerty",
+    "qwert",
+    "asdf",
+    "asdfgh",
+    "zxcvbn",
+    "zxcv",
+    "qazwsx",
+    "1qaz2wsx",
+    "qweasd",
+    "!@#$%",
+    "1234567890",
+    "0987654321",
+    "qwertyuiop",
+    "asdfghjkl",
+    "zxcvbnm",
+    "1q2w3e4r",
+    "q1w2e3r4",
+    "zaq1xsw2",
+    "1234qwer",
+    "poiuytrewq",
+    "lkjhgfdsa",
+    "mnbvcxz",
+    "!qaz2wsx3edc",
+    "1qaz!QAZ",
+]
+
+
+def static_keyboard_walks() -> List[str]:
+    """Return the built-in list of classic keyboard walk patterns."""
+    return list(STATIC_WALKS)
+
+
+def dynamic_keyboard_walks(min_len: int = 4, max_len: int = 8) -> List[str]:
+    """Generate all possible continuous keyboard walks up to *max_len*.
+
+    Uses BFS from each starting key, following adjacency relationships
+    on the QWERTY layout.  Only walks of length >= *min_len* are returned.
+
+    Note: This can produce a very large number of candidates.  For
+    max_len=8 the count is in the millions.  Use with caution.
+    """
+    results: Set[str] = set()
+
+    for start_key in _QWERTY_POS:
+        # BFS
+        queue: List[Tuple[str, str]] = [(start_key, start_key)]
+        while queue:
+            current, walk = queue.pop(0)
+            if len(walk) >= min_len:
+                results.add(walk)
+            if len(walk) >= max_len:
+                continue
+            for neighbour in _QWERTY_ADJ.get(current, []):
+                queue.append((neighbour, walk + neighbour))
+
+    return sorted(results)

pawpy/mutations/leet.py

@@ -0,0 +1,65 @@
+"""Leet-speak mutation engine.
+
+Supports multiple substitution tables and generates all possible
+combinations of leet substitutions for a given word.
+"""
+
+from __future__ import annotations
+
+import itertools
+from typing import Dict, List, Set
+
+# Comprehensive leet substitution maps
+_LEET_MAPS: List[Dict[str, List[str]]] = [
+    # Level 1: basic
+    {"a": ["@"], "e": ["3"], "i": ["1"], "o": ["0"], "s": ["$"], "t": ["7"]},
+    # Level 2: extended
+    {"a": ["@"], "e": ["3"], "i": ["1", "!"], "o": ["0"], "s": ["$", "5"], "t": ["7"]},
+    # Level 3: aggressive
+    {
+        "a": ["@", "4"],
+        "e": ["3"],
+        "i": ["1", "!"],
+        "o": ["0"],
+        "s": ["$", "5"],
+        "t": ["7"],
+        "l": ["1"],
+        "b": ["8"],
+        "g": ["9"],
+        "h": ["#"],
+    },
+]
+
+
+def leet_speak(word: str, level: int = 2) -> List[str]:
+    """Generate leet-speak variations of *word*.
+
+    For each character that has substitutions, generate all combinations
+    of original vs. substituted forms.  Returns a list of unique variants
+    (always includes the original word).
+
+    Args:
+        word: The base word to leetify.
+        level: Substitution table to use (1=basic, 2=extended, 3=aggressive).
+
+    Returns:
+        List of unique leet-speak variants.
+    """
+    level = max(1, min(level, len(_LEET_MAPS)))
+    table = _LEET_MAPS[level - 1]
+    results: Set[str] = set()
+
+    # Build a list of options per character position
+    char_options: List[List[str]] = []
+    for ch in word.lower():
+        subs = table.get(ch, [])
+        if subs:
+            char_options.append([ch] + subs)
+        else:
+            char_options.append([ch])
+
+    # Generate all combinations
+    for combo in itertools.product(*char_options):
+        results.add("".join(combo))
+
+    return sorted(results)