pawpy-cli 1.0.0__py3-none-any.whl

pawpy/profile/multi.py

@@ -0,0 +1,93 @@
+"""Multi-target profile handling with cross-referencing."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List
+
+from rich.console import Console
+
+console = Console()
+
+
+def load_multi_profiles(path: str) -> List[Dict[str, Any]]:
+    """Load a JSON array of profiles from *path*."""
+    with open(path, "r", encoding="utf-8") as fh:
+        data = json.load(fh)
+    if not isinstance(data, list):
+        raise ValueError(
+            f"Expected a JSON array of profiles in {path}, "
+            f"but got {type(data).__name__}. "
+            "Use -j / --import-json for a single profile."
+        )
+    return data
+
+
+def merge_profiles(profiles: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Merge multiple profiles into a single unified profile."""
+    merged: Dict[str, Any] = {
+        "firstname": [],
+        "lastname": [],
+        "nickname": [],
+        "birthdate": [],
+        "partner": [],
+        "partner_nick": [],
+        "partner_bdate": [],
+        "pet": [],
+        "company": [],
+        "hometown": [],
+        "favourite_color": [],
+        "children": [],
+        "keywords": [],
+    }
+    list_fields = {"children", "keywords"}
+
+    for profile in profiles:
+        for key in merged:
+            value = profile.get(key, "")
+            if key in list_fields:
+                if isinstance(value, list):
+                    merged[key].extend(v for v in value if v)
+            elif key in ("birthdate", "partner_bdate"):
+                if isinstance(value, str) and value.strip():
+                    merged[key].append(value.strip())
+            else:
+                if isinstance(value, str) and value.strip():
+                    merged[key].append(value.strip())
+
+    for key in merged:
+        seen = set()
+        unique = []
+        for item in merged[key]:
+            if item not in seen:
+                seen.add(item)
+                unique.append(item)
+        merged[key] = unique
+
+    console.print(
+        f"[green]✓[/green] Merged {len(profiles)} profiles into unified cross-referenced profile."
+    )
+    return merged
+
+
+def extract_merged_base_words(merged: Dict[str, Any]) -> List[str]:
+    """Flatten all fields from a merged profile into a deduplicated word list."""
+    words: set = set()
+    for key, value in merged.items():
+        if isinstance(value, list):
+            for item in value:
+                if isinstance(item, str) and item.strip():
+                    words.add(item.strip().lower())
+        elif isinstance(value, str) and value.strip():
+            words.add(value.strip().lower())
+    return sorted(words)
+
+
+def extract_merged_dates(merged: Dict[str, Any]) -> List[str]:
+    """Extract all date strings from a merged profile."""
+    dates: set = set()
+    for field in ("birthdate", "partner_bdate"):
+        for d in merged.get(field, []):
+            if isinstance(d, str) and d.strip():
+                dates.add(d.strip())
+    return sorted(dates)

pawpy/profile/plugins/__init__.py

@@ -0,0 +1,55 @@
+"""OSINT plugin system for Pawpy."""
+
+from __future__ import annotations
+
+import importlib.util
+import logging
+from pathlib import Path
+from typing import Any, Callable, Dict, List
+
+logger = logging.getLogger("pawpy.plugins")
+PluginFunc = Callable[[Dict[str, Any]], Dict[str, Any]]
+_plugins: List[PluginFunc] = []
+
+
+def _discover_plugins(plugin_dir=None) -> None:
+    if plugin_dir is None:
+        plugin_dir = Path(__file__).parent
+    else:
+        plugin_dir = Path(plugin_dir)
+    if not plugin_dir.is_dir():
+        return
+    for py_file in sorted(plugin_dir.glob("*.py")):
+        if py_file.name.startswith("__"):
+            continue
+        try:
+            spec = importlib.util.spec_from_file_location(
+                f"pawpy.plugins.{py_file.stem}", py_file
+            )
+            if spec is None or spec.loader is None:
+                continue
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            func = getattr(module, "collect", None)
+            if callable(func):
+                _plugins.append(func)
+                logger.info("Loaded OSINT plugin: %s", py_file.stem)
+        except Exception:
+            logger.exception("Failed to load plugin: %s", py_file.stem)
+
+
+def run_plugins(profile: Dict[str, Any]) -> Dict[str, Any]:
+    if not _plugins:
+        _discover_plugins()
+    for plugin_func in _plugins:
+        try:
+            profile = plugin_func(profile)
+        except Exception:
+            logger.exception("Plugin %s raised an exception", plugin_func.__name__)
+    return profile
+
+
+def list_plugins() -> List[str]:
+    if not _plugins:
+        _discover_plugins()
+    return [fn.__module__ for fn in _plugins]

pawpy/profile/plugins/example.py

@@ -0,0 +1,22 @@
+"""Example OSINT plugin – a template for plugin authors.
+
+This plugin demonstrates the expected interface.  Replace the body of
+``collect`` with real OSINT logic.  Always respect rate-limiting,
+terms of service, and privacy laws.  Only use OSINT data for authorised
+security testing.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+
+def collect(profile: Dict[str, Any]) -> Dict[str, Any]:
+    """Enrich *profile* with OSINT-derived data (example no-op)."""
+    if profile.get("firstname"):
+        keywords = profile.get("keywords", [])
+        if isinstance(keywords, str):
+            keywords = [keywords]
+        keywords.append("osint_enriched")
+        profile["keywords"] = keywords
+    return profile

pawpy/scoring/__init__.py

@@ -0,0 +1 @@
+"""Password strength scoring subsystem."""

pawpy/scoring/scorer.py

@@ -0,0 +1,66 @@
+"""zxcvbn-based password strength scoring and pruning."""
+
+from __future__ import annotations
+
+import logging
+from typing import List, Optional
+
+logger = logging.getLogger("pawpy.scorer")
+
+_zxcvbn_available = False
+try:
+    from zxcvbn import zxcvbn
+
+    _zxcvbn_available = True
+except ImportError:
+    zxcvbn = None  # type: ignore[assignment, misc]
+
+
+def is_zxcvbn_available() -> bool:
+    """Check whether zxcvbn library is installed."""
+    return _zxcvbn_available
+
+
+def score_password(password: str) -> Optional[int]:
+    """Score a password using zxcvbn.
+
+    Returns:
+        An integer score 0-4, or None if zxcvbn is not available.
+        0 = very weak, 4 = very strong.
+    """
+    if not _zxcvbn_available:
+        return None
+    try:
+        result = zxcvbn(password)
+        return result.get("score", 0)
+    except Exception:
+        logger.debug("zxcvbn failed on: %s", password[:20])
+        return None
+
+
+def score_and_prune(candidates: List[str], min_score: int) -> List[str]:
+    """Filter candidates to those with zxcvbn score >= *min_score*.
+
+    If zxcvbn is not available, returns all candidates unchanged.
+    """
+    if not _zxcvbn_available:
+        logger.warning("zxcvbn not installed – skipping strength scoring.")
+        return candidates
+
+    min_score = max(0, min(min_score, 4))
+    kept = []
+    pruned = 0
+    for candidate in candidates:
+        score = score_password(candidate)
+        if score is not None and score < min_score:
+            pruned += 1
+            continue
+        kept.append(candidate)
+
+    logger.info(
+        "zxcvbn scoring: kept %d, pruned %d (min_score=%d)",
+        len(kept),
+        pruned,
+        min_score,
+    )
+    return kept

pawpy/utils.py

@@ -0,0 +1,136 @@
+"""Shared utilities: banner, dedup writer, logging helpers."""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Generator, Iterable, Set
+
+from rich.console import Console
+from rich.logging import RichHandler
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskProgressColumn,
+    TextColumn,
+    TimeRemainingColumn,
+)
+
+# ---------------------------------------------------------------------------
+# Console & logging
+# ---------------------------------------------------------------------------
+
+console = Console()
+
+
+def setup_logging(verbose: bool = False) -> logging.Logger:
+    """Create and return the pawpy logger."""
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(message)s",
+        datefmt="[%X]",
+        handlers=[RichHandler(console=console, rich_tracebacks=True)],
+    )
+    return logging.getLogger("pawpy")
+
+
+# ---------------------------------------------------------------------------
+# ASCII Banner
+# ---------------------------------------------------------------------------
+
+BANNER_TEXT = r"""
+██████╗  █████╗ ██╗    ██╗██████╗ ██╗   ██╗
+██╔══██╗██╔══██╗██║    ██║██╔══██╗╚██╗ ██╔╝
+██████╔╝███████║██║ █╗ ██║██████╔╝ ╚████╔╝ 
+██╔═══╝ ██╔══██║██║███╗██║██╔═══╝   ╚██╔╝  
+██║     ██║  ██║╚███╔███╔╝██║        ██║   
+╚═╝     ╚═╝  ╚═╝ ╚══╝╚══╝ ╚═╝        ╚═╝   
+     The Most Powerful Wordlist Generator
+"""
+
+ETHICAL_WARNING = (
+    "[bold red]⚠  ETHICAL USE ONLY[/bold red]\n"
+    "This tool is intended for [bold]authorised security testing and educational purposes only[/bold].\n"
+    "Unauthorised use against systems or accounts you do not own or have explicit\n"
+    "permission to test is [bold red]illegal and unethical[/bold red].\n"
+    "By proceeding, you confirm you have proper authorisation.\n"
+)
+
+
+def print_banner() -> None:
+    """Display the Pawpy ASCII banner and ethical-use warning."""
+    console.print(BANNER_TEXT, style="bold cyan")
+    console.print(
+        f"  v{__import__('pawpy').__version__}  |  The Most Powerful Educational Wordlist Generator",
+        style="dim",
+    )
+    console.print()
+    console.print(ETHICAL_WARNING)
+    console.print()
+
+
+# ---------------------------------------------------------------------------
+# Dedup & streaming helpers
+# ---------------------------------------------------------------------------
+
+
+def dedup_stream(
+    lines: Iterable[str],
+    output_path: str,
+) -> int:
+    """Deduplicate an iterable of strings and write sorted output to *output_path*.
+
+    Returns the number of unique lines written.
+    """
+    seen: Set[str] = set()
+    count = 0
+    tmp = output_path + ".tmp"
+    with open(tmp, "w", encoding="utf-8", errors="ignore") as fh:
+        for line in lines:
+            line = line.rstrip("\n\r")
+            if line and line not in seen:
+                seen.add(line)
+                fh.write(line + "\n")
+                count += 1
+    os.replace(tmp, output_path)
+    return count
+
+
+def iter_file(path: str) -> Generator[str, None, None]:
+    """Yield non-empty lines from a text file."""
+    with open(path, "r", encoding="utf-8", errors="ignore") as fh:
+        for line in fh:
+            stripped = line.rstrip("\n\r")
+            if stripped:
+                yield stripped
+
+
+def make_progress() -> Progress:
+    """Create a standard Rich progress bar."""
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        TimeRemainingColumn(),
+        console=console,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Confirmation prompt
+# ---------------------------------------------------------------------------
+
+
+def confirm_ethical_use() -> bool:
+    """Prompt the user to confirm ethical use. Returns True on 'y'."""
+    return (
+        console.input(
+            "[bold yellow]Do you confirm you have authorisation? {y/N}: [/bold yellow]"
+        )
+        .strip()
+        .lower()
+        == "y"
+    )