pawpy-cli 1.0.0b0__py3-none-any.whl

pawpy/mutations/mangle.py

@@ -0,0 +1,238 @@
+"""Common mangle rules and Hashcat/John-style rule engine."""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import List, Optional
+
+logger = logging.getLogger("pawpy.mangle")
+
+# Common append/prepend strings
+APPENDS = [
+    "",
+    "1",
+    "2",
+    "3",
+    "12",
+    "13",
+    "21",
+    "22",
+    "23",
+    "99",
+    "123",
+    "1234",
+    "!",
+    "@",
+    "#",
+    "$",
+    "!!",
+    "!@#",
+    "01",
+    "69",
+    "!",
+    "?",
+    "*",
+    ".",
+    "_",
+    "-",
+    "@1",
+    "@123",
+    "#1",
+]
+PREPENDS = ["", "1", "123", "!", "@", "#", "$", "?", "*"]
+
+
+def mangle_rules(word: str) -> List[str]:
+    """Apply common mangle rules: capitalise, upper, reverse, append, prepend.
+
+    Returns a list of mutated variants (always includes the original).
+    """
+    results = set()
+    results.add(word)
+    results.add(word.capitalize())
+    results.add(word.upper())
+    results.add(word.lower())
+    results.add(word[::-1])  # reverse
+    results.add(word.swapcase())
+    results.add(word[0].upper() + word[1:].lower() if word else word)
+    # toggle first and last case
+    if len(word) > 1:
+        results.add(word[0].upper() + word[1:-1] + word[-1].upper())
+
+    for suffix in APPENDS:
+        results.add(word + suffix)
+        results.add(word.capitalize() + suffix)
+
+    for prefix in PREPENDS:
+        if prefix:  # skip empty prefix (already have original)
+            results.add(prefix + word)
+            results.add(prefix + word.capitalize())
+
+    return sorted(results)
+
+
+# ---------------------------------------------------------------------------
+# Hashcat / John the Ripper rule engine
+# ---------------------------------------------------------------------------
+
+
+def _apply_rule(word: str, rule: str) -> Optional[str]:
+    """Apply a single hashcat-style rule to *word*.
+
+    Supported rules (subset of hashcat):
+    - Lowercase:  l  /  : (legacy)
+    - Uppercase:  u
+    - Capitalise: c  (first char upper, rest lower)
+    - Swap case:  s
+    - Reverse:    r
+    - Append:     $X  (append char X)
+    - Prepend:    ^X  (prepend char X)
+    - Truncate left:  [N  (keep first N chars)
+    - Truncate right: ]N  (keep last N chars)
+    - Insert at pos:  iNX  (insert char X at position N)
+    - Overwrite at pos: oNX  (overwrite char at position N with X)
+    - Duplicate:  d
+    - Duplicate first: p
+    - Duplicate last:  z
+    - Replace:    sXY  (replace all X with Y)
+    """
+    w = list(word)
+
+    i = 0
+    while i < len(rule):
+        cmd = rule[i]
+
+        if cmd == "l":
+            w = [c.lower() for c in w]
+            i += 1
+        elif cmd == "u":
+            w = [c.upper() for c in w]
+            i += 1
+        elif cmd == "c":
+            if w:
+                w = [w[0].upper()] + [c.lower() for c in w[1:]]
+            i += 1
+        elif cmd == "s":
+            w = [c.swapcase() for c in w]
+            i += 1
+        elif cmd == "r":
+            w = w[::-1]
+            i += 1
+        elif cmd == "d":
+            w = w + w
+            i += 1
+        elif cmd == "p":
+            if w:
+                w = [w[0]] + w
+            i += 1
+        elif cmd == "z":
+            if w:
+                w = w + [w[-1]]
+            i += 1
+        elif cmd == "$":
+            # Append next char
+            if i + 1 < len(rule):
+                w.append(rule[i + 1])
+                i += 2
+            else:
+                i += 1
+        elif cmd == "^":
+            # Prepend next char
+            if i + 1 < len(rule):
+                w.insert(0, rule[i + 1])
+                i += 2
+            else:
+                i += 1
+        elif cmd == "[":
+            # Truncate from left – keep first N
+            m = re.match(r"\[(\d+)", rule[i:])
+            if m:
+                n = int(m.group(1))
+                w = w[:n]
+                i += 1 + len(m.group(1))
+            else:
+                i += 1
+        elif cmd == "]":
+            # Truncate from right – keep last N
+            m = re.match(r"\](\d+)", rule[i:])
+            if m:
+                n = int(m.group(1))
+                w = w[-n:] if n > 0 else []
+                i += 1 + len(m.group(1))
+            else:
+                i += 1
+        elif cmd == "i":
+            # Insert char X at position N: iNX
+            m = re.match(r"i(\d+)(.)", rule[i:])
+            if m:
+                pos = int(m.group(1))
+                ch = m.group(2)
+                if pos <= len(w):
+                    w.insert(pos, ch)
+                i += 1 + len(m.group(1)) + 1
+            else:
+                i += 1
+        elif cmd == "o":
+            # Overwrite char at position N with X: oNX
+            m = re.match(r"o(\d+)(.)", rule[i:])
+            if m:
+                pos = int(m.group(1))
+                ch = m.group(2)
+                if 0 <= pos < len(w):
+                    w[pos] = ch
+                i += 1 + len(m.group(1)) + 1
+            else:
+                i += 1
+        elif cmd == "'":
+            # Replace all X with Y: sXY (or 'XY in john format)
+            if i + 2 < len(rule):
+                old_ch = rule[i + 1]
+                new_ch = rule[i + 2]
+                w = [new_ch if c == old_ch else c for c in w]
+                i += 3
+            else:
+                i += 1
+        else:
+            # Unknown rule – skip
+            i += 1
+
+    return "".join(w)
+
+
+def apply_hashcat_rules(word: str, rules: List[str]) -> List[str]:
+    """Apply a list of hashcat-style rules to *word*.
+
+    Each rule string may contain multiple rule commands (applied left to
+    right).  Returns the list of results.
+
+    Args:
+        word: The base word.
+        rules: A list of rule strings, one per line (as read from a .rule file).
+
+    Returns:
+        List of mutated words. Empty results are excluded.
+    """
+    results = set()
+    for rule in rules:
+        rule = rule.strip()
+        if not rule or rule.startswith("#"):
+            continue
+        try:
+            mutated = _apply_rule(word, rule)
+            if mutated:
+                results.add(mutated)
+        except Exception:
+            logger.debug("Failed to apply rule '%s' to '%s'", rule, word)
+    return sorted(results)
+
+
+def load_rules_file(path: str) -> List[str]:
+    """Load rules from a hashcat .rule file (one rule per line)."""
+    rules = []
+    with open(path, "r", encoding="utf-8", errors="ignore") as fh:
+        for line in fh:
+            stripped = line.strip()
+            if stripped and not stripped.startswith("#"):
+                rules.append(stripped)
+    return rules

pawpy/mutations/markov.py

@@ -0,0 +1,125 @@
+"""Markov chain-based password generation.
+
+Trains a character-level Markov model on a corpus of words and
+generates new candidate passwords that follow similar patterns.
+"""
+
+from __future__ import annotations
+
+import logging
+import random
+from collections import defaultdict
+from typing import Dict, List, Optional
+
+logger = logging.getLogger("pawpy.markov")
+
+
+class MarkovModel:
+    """Character-level Markov chain for password generation.
+
+    The model records the probability of each character following a
+    sequence of *order* previous characters.  Generation starts from
+    a random seed and follows the chain until a stop condition.
+    """
+
+    def __init__(self, order: int = 2) -> None:
+        self.order = order
+        # transition_table[context][next_char] = count
+        self.transition_table: Dict[str, Dict[str, int]] = defaultdict(
+            lambda: defaultdict(int)
+        )
+        self.total_chars = 0
+
+    def train(self, words: List[str]) -> None:
+        """Train the model on a list of words."""
+        for word in words:
+            w = word.lower().strip()
+            if not w:
+                continue
+            # Pad start and end
+            padded = "^" * self.order + w + "$"
+            for i in range(len(padded) - self.order):
+                context = padded[i : i + self.order]
+                next_char = padded[i + self.order]
+                self.transition_table[context][next_char] += 1
+                self.total_chars += 1
+
+        logger.debug(
+            "Markov model trained: order=%d, contexts=%d, total_chars=%d",
+            self.order,
+            len(self.transition_table),
+            self.total_chars,
+        )
+
+    def generate(self, min_len: int = 6, max_len: int = 16) -> Optional[str]:
+        """Generate a single password from the trained model."""
+        if not self.transition_table:
+            return None
+
+        # Start from a random context
+        contexts = [ctx for ctx in self.transition_table if all(c == "^" for c in ctx)]
+        if not contexts:
+            return None
+
+        context = random.choice(contexts)
+        result = ""
+
+        for _ in range(max_len):
+            if context not in self.transition_table:
+                break
+            next_chars = self.transition_table[context]
+            if not next_chars:
+                break
+
+            # Weighted random choice
+            total = sum(next_chars.values())
+            r = random.randint(1, total)
+            cumulative = 0
+            chosen = "$"  # default: end
+            for ch, count in next_chars.items():
+                cumulative += count
+                if cumulative >= r:
+                    chosen = ch
+                    break
+
+            if chosen == "$":
+                break
+            result += chosen
+            context = context[1:] + chosen
+
+        if len(result) < min_len:
+            return None
+        return result
+
+    def generate_many(
+        self, count: int, min_len: int = 6, max_len: int = 16
+    ) -> List[str]:
+        """Generate *count* unique passwords."""
+        results: set = set()
+        attempts = 0
+        max_attempts = count * 10
+        while len(results) < count and attempts < max_attempts:
+            word = self.generate(min_len, max_len)
+            if word:
+                results.add(word)
+            attempts += 1
+        return sorted(results)
+
+
+def train_markov(words: List[str], order: int = 2) -> MarkovModel:
+    """Convenience function: create, train, and return a MarkovModel."""
+    model = MarkovModel(order=order)
+    model.train(words)
+    return model
+
+
+def generate_markov_words(
+    words: List[str],
+    count: int = 5000,
+    order: int = 2,
+    min_len: int = 6,
+    max_len: int = 16,
+) -> List[str]:
+    """Train a Markov model on *words* and generate *count* candidates."""
+    model = train_markov(words, order=order)
+    return model.generate_many(count, min_len, max_len)

pawpy/mutations/templates.py

@@ -0,0 +1,131 @@
+"""Custom pattern template engine.
+
+Expands templates like ``[FirstName][Year][Special]`` by substituting
+profile fields and generating combinatorial expansions.
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from typing import Any, Dict, List
+
+# Recognised template tokens (inside [brackets])
+_TOKEN_RE = re.compile(r"\[([A-Za-z_]+)\]")
+
+# Special character sets used by some tokens
+_SPECIALS = ["!", "@", "#", "$", "%", "^", "&", "*", "?", ".", "_", "-"]
+_DIGITS = [str(i) for i in range(10)]
+
+# Current year
+_CURRENT_YEAR = datetime.now().year
+
+
+def _resolve_token(token: str, profile: Dict[str, Any]) -> List[str]:
+    """Resolve a single template token to a list of possible values."""
+    t = token.lower()
+
+    # Direct profile fields
+    field_map = {
+        "firstname": "firstname",
+        "lastname": "lastname",
+        "nickname": "nickname",
+        "partner": "partner",
+        "partner_nick": "partner_nick",
+        "pet": "pet",
+        "company": "company",
+        "hometown": "hometown",
+        "color": "favourite_color",
+        "favourite_color": "favourite_color",
+    }
+    if t in field_map:
+        val = profile.get(field_map[t], "")
+        if isinstance(val, str) and val.strip():
+            return [val, val.capitalize(), val.upper(), val.lower()]
+        return []
+
+    # Date-related tokens
+    if t in ("year", "yr"):
+        return [str(_CURRENT_YEAR - i) for i in range(40)]  # 1986..current
+    if t in ("year2", "yr2"):
+        return [str(y)[-2:] for y in range(_CURRENT_YEAR - 40, _CURRENT_YEAR + 1)]
+    if t == "date":
+        bd = profile.get("birthdate", "")
+        return [bd] if isinstance(bd, str) and bd.strip() else []
+
+    # Character class tokens
+    if t == "digit":
+        return _DIGITS
+    if t in ("special", "spec", "sym"):
+        return _SPECIALS
+    if t == "upper":
+        return [chr(c) for c in range(ord("A"), ord("Z") + 1)]
+    if t == "lower":
+        return [chr(c) for c in range(ord("a"), ord("z") + 1)]
+
+    # Children / keywords
+    if t in ("child", "children"):
+        val = profile.get("children", [])
+        if isinstance(val, list):
+            return [c for c in val if isinstance(c, str) and c.strip()]
+        return []
+    if t == "keyword" or t == "keywords":
+        val = profile.get("keywords", [])
+        if isinstance(val, list):
+            return [k for k in val if isinstance(k, str) and k.strip()]
+        return []
+
+    # Static tokens
+    if t == "sep":
+        return ["_", "-", ".", "", "@", "#"]
+    if t == "123":
+        return ["123", "1234", "12345", "!@#", "1q2w3e"]
+
+    return []
+
+
+def expand_templates(
+    templates: List[str],
+    profile: Dict[str, Any],
+    max_combinations: int = 100_000,
+) -> List[str]:
+    """Expand a list of template strings using profile data.
+
+    Each template may contain ``[Token]`` placeholders which are resolved
+    via ``_resolve_token``.  All combinations are generated.
+
+    Args:
+        templates: List of template strings like ``[FirstName][Year][!]``.
+        profile: Target profile dictionary.
+        max_combinations: Safety limit on total output size.
+
+    Returns:
+        List of expanded password candidates.
+    """
+    results = []
+    total = 0
+
+    for tmpl in templates:
+        # Find all tokens in order
+        tokens = _TOKEN_RE.findall(tmpl)
+        if not tokens:
+            results.append(tmpl)
+            continue
+
+        # Resolve each token to its possible values
+        token_values = [_resolve_token(tok, profile) for tok in tokens]
+
+        # Cartesian product
+        import itertools
+
+        for combo in itertools.product(*token_values):
+            if total >= max_combinations:
+                return results
+            candidate = tmpl
+            for tok, val in zip(tokens, combo):
+                candidate = candidate.replace(f"[{tok}]", val, 1)
+                candidate = candidate.replace(f"[{tok.lower()}]", val, 1)
+            results.append(candidate)
+            total += 1
+
+    return results

pawpy/profile/__init__.py

@@ -0,0 +1,5 @@
+"""Profile collection subsystem."""
+
+from pawpy.profile.base import ProfileCollector
+
+__all__ = ["ProfileCollector"]

pawpy/profile/base.py

@@ -0,0 +1,161 @@
+"""Profile collector – interactive (CUPP-style) and JSON import."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict, List
+
+from rich.console import Console
+
+console = Console()
+logger = logging.getLogger("pawpy.profile")
+
+
+class ProfileCollector:
+    """Collect target profile data interactively or from JSON."""
+
+    # Standard fields expected in a profile
+    FIELDS = [
+        "firstname",
+        "lastname",
+        "nickname",
+        "birthdate",
+        "partner",
+        "partner_nick",
+        "partner_bdate",
+        "pet",
+        "company",
+        "hometown",
+        "favourite_color",
+    ]
+    LIST_FIELDS = ["children", "keywords"]
+
+    def __init__(self) -> None:
+        self._profile: Dict[str, Any] = {k: "" for k in self.FIELDS}
+        self._profile["children"] = []
+        self._profile["keywords"] = []
+
+    # ------------------------------------------------------------------
+    # Interactive collection
+    # ------------------------------------------------------------------
+
+    def interactive_collect(self) -> Dict[str, Any]:
+        """Present a CUPP-style questionnaire and return the profile dict."""
+        console.print("\n[bold cyan]── Target Profile Collection ──[/bold cyan]\n")
+
+        prompts = {
+            "firstname": ("First name", "John"),
+            "lastname": ("Last name", "Doe"),
+            "nickname": ("Nickname", "Johnny"),
+            "birthdate": ("Birthdate (DDMMYYYY)", "01011990"),
+            "partner": ("Partner's first name", ""),
+            "partner_nick": ("Partner's nickname", ""),
+            "partner_bdate": ("Partner's birthdate (DDMMYYYY)", ""),
+            "pet": ("Pet's name", ""),
+            "company": ("Company / organisation", ""),
+            "hometown": ("City / hometown", ""),
+            "favourite_color": ("Favourite colour", ""),
+        }
+
+        for field, (label, example) in prompts.items():
+            answer = console.input(
+                f"  [dim]{label}[/dim] [dim](e.g. {example})[/dim]: "
+            ).strip()
+            self._profile[field] = answer
+
+        children_raw = console.input(
+            "  [dim]Children's names (comma-separated)[/dim]: "
+        ).strip()
+        self._profile["children"] = [
+            c.strip() for c in children_raw.split(",") if c.strip()
+        ]
+
+        keywords_raw = console.input(
+            "  [dim]Keywords / interests (comma-separated)[/dim]: "
+        ).strip()
+        self._profile["keywords"] = [
+            k.strip() for k in keywords_raw.split(",") if k.strip()
+        ]
+
+        console.print()
+        return self._profile
+
+    # ------------------------------------------------------------------
+    # JSON import
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def from_json(path: str) -> Dict[str, Any]:
+        """Load a single profile from a JSON file.
+
+        Raises ``ValueError`` if the file contains a JSON array (use
+        ``--multi`` for arrays).
+        """
+        with open(path, "r", encoding="utf-8") as fh:
+            data = json.load(fh)
+        if isinstance(data, list):
+            raise ValueError(
+                f"File '{path}' contains a JSON array of profiles. "
+                "Use --multi to import multiple profiles."
+            )
+        return data
+
+    # ------------------------------------------------------------------
+    # Word / date extraction
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def extract_base_words(profile: Dict[str, Any]) -> List[str]:
+        """Extract all non-empty text values from a profile as lowercase words.
+
+        String fields yield one word each; list fields yield one word per
+        element.  The result is deduplicated and sorted.
+        """
+        words: set = set()
+        list_fields = {"children", "keywords"}
+        for key, value in profile.items():
+            if key in list_fields:
+                if isinstance(value, list):
+                    for item in value:
+                        if isinstance(item, str) and item.strip():
+                            words.add(item.strip().lower())
+            else:
+                if isinstance(value, str) and value.strip():
+                    words.add(value.strip().lower())
+        return sorted(words)
+
+    @staticmethod
+    def extract_dates(profile: Dict[str, Any]) -> List[str]:
+        """Return date strings found in the profile (birthdate, partner_bdate)."""
+        dates = []
+        for field in ("birthdate", "partner_bdate"):
+            val = profile.get(field, "")
+            if isinstance(val, str) and val.strip():
+                dates.append(val.strip())
+        return dates
+
+    # ------------------------------------------------------------------
+    # Main entry point
+    # ------------------------------------------------------------------
+
+    def run(self, config) -> Dict[str, Any]:
+        """Collect profile based on configuration.
+
+        If *config.profile_json* is set, load from file; otherwise
+        run the interactive questionnaire.  Optionally run OSINT plugins.
+        """
+        from pawpy.profile.plugins import run_plugins  # lazy import
+
+        if config.profile_json:
+            self._profile = self.from_json(config.profile_json)
+            console.print(
+                f"[green]✓[/green] Loaded profile from [bold]{config.profile_json}[/bold]"
+            )
+        else:
+            self._profile = self.interactive_collect()
+
+        # Run OSINT plugins if any are installed
+        self._profile = run_plugins(self._profile)
+
+        return self._profile