souleyez 2.43.28__py3-none-any.whl → 2.43.32__py3-none-any.whl

souleyez/utils.py

@@ -7,9 +7,9 @@ import re
 import platform
 import ipaddress
 
-APP_DIR = Path.home() / '.souleyez'
-SCANS_DIR = APP_DIR / 'scans'
-HISTORY_FILE = APP_DIR / 'recon_history.json'
+APP_DIR = Path.home() / ".souleyez"
+SCANS_DIR = APP_DIR / "scans"
+HISTORY_FILE = APP_DIR / "recon_history.json"
 
 
 def ensure_dirs():
@@ -18,46 +18,50 @@ def ensure_dirs():
 
 
 def nmap_installed():
-    return shutil.which('nmap') is not None
+    return shutil.which("nmap") is not None
 
 
 def timestamp_str():
     from datetime import datetime
-    return datetime.now().strftime('%Y%m%d-%H%M%S')
+
+    return datetime.now().strftime("%Y%m%d-%H%M%S")
 
 
 def join_cmd(args):
     import shlex
-    return ' '.join(shlex.quote(a) for a in args)
+
+    return " ".join(shlex.quote(a) for a in args)
 
 
 def read_json(path):
     try:
-        with open(path, 'r') as f:
+        with open(path, "r") as f:
             return json.load(f)
     except Exception:
         return []
 
 
 def write_json(path, data):
-    with open(path, 'w') as f:
+    with open(path, "w") as f:
         json.dump(data, f, indent=2)
 
 
 def _run(cmd):
     try:
-        return subprocess.run(cmd, capture_output=True, text=True, check=False).stdout.strip()
+        return subprocess.run(
+            cmd, capture_output=True, text=True, check=False
+        ).stdout.strip()
     except Exception:
-        return ''
+        return ""
 
 
 def _hexmask_to_prefix(hexmask):
     try:
-        if hexmask.startswith('0x'):
+        if hexmask.startswith("0x"):
             val = int(hexmask, 16)
             mask_bytes = [(val >> (i * 8)) & 0xFF for i in (3, 2, 1, 0)]
-            bits = ''.join(f'{b:08b}' for b in mask_bytes)
-            return bits.count('1')
+            bits = "".join(f"{b:08b}" for b in mask_bytes)
+            return bits.count("1")
     except Exception:
         pass
     return None
@@ -66,38 +70,38 @@ def _hexmask_to_prefix(hexmask):
 def detect_local_subnet():
     system = platform.system().lower()
     cidr = None
-    if system == 'linux':
-        out = _run(['ip', 'route', 'get', '8.8.8.8'])
-        m = re.search(r'src (\S+)', out)
+    if system == "linux":
+        out = _run(["ip", "route", "get", "8.8.8.8"])
+        m = re.search(r"src (\S+)", out)
         if m:
             ip_src = m.group(1)
-            out2 = _run(['ip', '-o', '-4', 'addr', 'show'])
-            m2 = re.search(rf'{re.escape(ip_src)}/(\d+)', out2)
+            out2 = _run(["ip", "-o", "-4", "addr", "show"])
+            m2 = re.search(rf"{re.escape(ip_src)}/(\d+)", out2)
             if m2:
-                cidr = f'{ip_src}/{m2.group(1)}'
+                cidr = f"{ip_src}/{m2.group(1)}"
     else:
-        out = _run(['route', '-n', 'get', '8.8.8.8'])
-        m = re.search(r'source address: (\S+)', out)
+        out = _run(["route", "-n", "get", "8.8.8.8"])
+        m = re.search(r"source address: (\S+)", out)
         if m:
             ip_src = m.group(1)
-            ic = _run(['ifconfig'])
-            m3 = re.search(rf'{re.escape(ip_src)} netmask (0x[0-9a-fA-F]+)', ic)
+            ic = _run(["ifconfig"])
+            m3 = re.search(rf"{re.escape(ip_src)} netmask (0x[0-9a-fA-F]+)", ic)
             if m3:
                 prefix = _hexmask_to_prefix(m3.group(1))
                 if prefix:
-                    cidr = f'{ip_src}/{prefix}'
+                    cidr = f"{ip_src}/{prefix}"
     if not cidr:
-        out3 = _run(['ip', '-o', '-4', 'addr', 'show'])
-        m4 = re.search(r'inet (\d+\.\d+\.\d+\.\d+)/(\d+)', out3)
+        out3 = _run(["ip", "-o", "-4", "addr", "show"])
+        m4 = re.search(r"inet (\d+\.\d+\.\d+\.\d+)/(\d+)", out3)
         if m4:
-            cidr = f'{m4.group(1)}/{m4.group(2)}'
+            cidr = f"{m4.group(1)}/{m4.group(2)}"
     if not cidr:
         return None
     try:
         return str(ipaddress.ip_interface(cidr).network)
     except Exception:
         try:
-            ip = cidr.split('/')[0]
-            return str(ipaddress.ip_network(ip + '/24', strict=False))
+            ip = cidr.split("/")[0]
+            return str(ipaddress.ip_network(ip + "/24", strict=False))
         except Exception:
             return None

souleyez/wordlists.py

@@ -22,14 +22,14 @@ def resolve_wordlist_path(relative_path: str) -> str:
         Absolute path to the wordlist file, or original path if not found
     """
     # If it's already an absolute path, return as-is
-    if relative_path.startswith('/'):
+    if relative_path.startswith("/"):
         return relative_path
 
     # Extract just the filename if it's a data/wordlists/ path
-    if 'data/wordlists/' in relative_path:
-        filename = relative_path.split('data/wordlists/')[-1]
-    elif relative_path.startswith('wordlists/'):
-        filename = relative_path.replace('wordlists/', '', 1)
+    if "data/wordlists/" in relative_path:
+        filename = relative_path.split("data/wordlists/")[-1]
+    elif relative_path.startswith("wordlists/"):
+        filename = relative_path.replace("wordlists/", "", 1)
     else:
         filename = relative_path
 
@@ -62,10 +62,10 @@ def resolve_args_wordlists(args: list) -> list:
     """
     resolved = []
     for arg in args:
-        if isinstance(arg, str) and 'data/wordlists/' in arg:
+        if isinstance(arg, str) and "data/wordlists/" in arg:
             # Check if this is a KEY=value format (e.g., USER_FILE=data/wordlists/foo.txt)
-            if '=' in arg:
-                key, value = arg.split('=', 1)
+            if "=" in arg:
+                key, value = arg.split("=", 1)
                 resolved_path = resolve_wordlist_path(value)
                 resolved.append(f"{key}={resolved_path}")
             else:
@@ -84,7 +84,7 @@ def ensure_user_wordlists():
     user_wordlist_dir = Path.home() / ".souleyez" / "data" / "wordlists"
 
     # Only do this once
-    if user_wordlist_dir.exists() and any(user_wordlist_dir.glob('*.txt')):
+    if user_wordlist_dir.exists() and any(user_wordlist_dir.glob("*.txt")):
         return
 
     # Try to find source wordlists
@@ -95,7 +95,7 @@ def ensure_user_wordlists():
 
     source_dir = None
     for d in source_dirs:
-        if d.exists() and any(d.glob('*.txt')):
+        if d.exists() and any(d.glob("*.txt")):
             source_dir = d
             break
 
@@ -106,7 +106,8 @@ def ensure_user_wordlists():
     user_wordlist_dir.mkdir(parents=True, exist_ok=True)
 
     import shutil
-    for src_file in source_dir.glob('*.txt'):
+
+    for src_file in source_dir.glob("*.txt"):
         dst_file = user_wordlist_dir / src_file.name
         if not dst_file.exists():
             try:
@@ -116,92 +117,103 @@ def ensure_user_wordlists():
 
 
 wordlist_map = {
+    # All wordlists are now self-contained in the project
+    # No external dependencies on /usr/share/* paths
     "hydra": {
         "users": [
+            "data/wordlists/usernames_common.txt",
             "data/wordlists/all_users.txt",
-            "data/wordlists/linux_users.txt",
-            "/usr/share/metasploit-framework/data/wordlists/unix_users.txt",
-            "/usr/share/seclists/Usernames/top-usernames-shortlist.txt"
+            "data/wordlists/ad_users.txt",
         ],
         "passwords": [
-            "data/wordlists/top20_quick.txt",
+            "data/wordlists/passwords_brute.txt",
             "data/wordlists/top100.txt",
-            "/usr/share/wordlists/rockyou.txt",
-            "/usr/share/wordlists/fasttrack.txt"
-        ]
+            "data/wordlists/top20_quick.txt",
+        ],
     },
-    
     "medusa": {
         "users": [
+            "data/wordlists/usernames_common.txt",
             "data/wordlists/all_users.txt",
-            "data/wordlists/linux_users.txt",
-            "/usr/share/metasploit-framework/data/wordlists/unix_users.txt"
         ],
         "passwords": [
-            "data/wordlists/top20_quick.txt",
+            "data/wordlists/passwords_brute.txt",
             "data/wordlists/top100.txt",
-            "/usr/share/wordlists/rockyou.txt"
-        ]
+        ],
     },
-    
     "gobuster": {
         "dirs": [
+            "data/wordlists/web_dirs_large.txt",
             "data/wordlists/web_dirs_common.txt",
-            "/usr/share/wordlists/dirb/common.txt",
-            "/usr/share/seclists/Discovery/Web-Content/common.txt",
-            "/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt"
         ],
         "files": [
             "data/wordlists/web_files_common.txt",
-            "/usr/share/seclists/Discovery/Web-Content/raft-small-files.txt"
         ],
         "dns": [
+            "data/wordlists/subdomains_large.txt",
             "data/wordlists/subdomains_common.txt",
-            "/usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt"
         ],
         "extensions": [
-            "data/wordlists/web_extensions.txt"
-        ]
+            "data/wordlists/web_extensions.txt",
+        ],
     },
-    
     "dirb": {
         "wordlist": [
+            "data/wordlists/web_dirs_large.txt",
             "data/wordlists/web_dirs_common.txt",
-            "/usr/share/wordlists/dirb/common.txt",
-            "/usr/share/wordlists/dirb/big.txt"
         ]
     },
-    
     "wfuzz": {
         "wordlist": [
+            "data/wordlists/web_dirs_large.txt",
             "data/wordlists/web_dirs_common.txt",
-            "/usr/share/wfuzz/wordlist/general/common.txt"
         ]
     },
-    
+    "ffuf": {
+        "dirs": [
+            "data/wordlists/web_dirs_large.txt",
+            "data/wordlists/web_dirs_common.txt",
+        ],
+        "api": [
+            "data/wordlists/api_endpoints_large.txt",
+            "data/wordlists/api_endpoints.txt",
+        ],
+        "params": [
+            "data/wordlists/web_files_common.txt",
+        ],
+    },
     "msf_auxiliary": {
         "users": [
-            "data/wordlists/all_users.txt",
-            "data/wordlists/linux_users.txt",
-            "/usr/share/metasploit-framework/data/wordlists/unix_users.txt"
+            "data/wordlists/usernames_common.txt",
+            "data/wordlists/soul_users.txt",
         ],
         "passwords": [
-            "data/wordlists/msf_passwords.txt",
+            "data/wordlists/passwords_brute.txt",
             "data/wordlists/top20_quick.txt",
-            "/usr/share/metasploit-framework/data/wordlists/unix_passwords.txt"
-        ]
+        ],
     },
-    
     "ncrack": {
         "users": [
+            "data/wordlists/usernames_common.txt",
             "data/wordlists/all_users.txt",
-            "data/wordlists/linux_users.txt"
         ],
         "passwords": [
-            "data/wordlists/top20_quick.txt",
-            "data/wordlists/top100.txt"
+            "data/wordlists/passwords_brute.txt",
+            "data/wordlists/top100.txt",
+        ],
+    },
+    "hashcat": {
+        "passwords": [
+            "data/wordlists/passwords_crack.txt",
+            "data/wordlists/passwords_brute.txt",
         ]
-    }
+    },
+    "john": {
+        "passwords": [
+            "data/wordlists/passwords_crack.txt",
+            "data/wordlists/passwords_brute.txt",
+        ]
+    },
 }
 
 
@@ -260,20 +272,20 @@ def _discover_wordlists_by_category(wordlist_dir, category):
     import os
 
     # Special handling for categories that should show all wordlists
-    show_all_categories = {'users', 'passwords'}
+    show_all_categories = {"users", "passwords"}
 
     # Category-specific patterns (only for non-show-all categories)
     category_patterns = {
-        'dirs': ['_dirs', 'directories'],
-        'files': ['_files'],
-        'dns': ['subdomains', 'dns'],
-        'wordlist': []  # Generic - include all
+        "dirs": ["_dirs", "directories"],
+        "files": ["_files"],
+        "dns": ["subdomains", "dns"],
+        "wordlist": [],  # Generic - include all
     }
 
     matches = []
 
     try:
-        for file in sorted(wordlist_dir.glob('*.txt')):
+        for file in sorted(wordlist_dir.glob("*.txt")):
             filename = file.name.lower()
 
             # For users/passwords, show ALL wordlists
@@ -310,7 +322,9 @@ def get_wordlist_info(wordlist_path):
 
     try:
         with open(wordlist_path) as f:
-            line_count = sum(1 for line in f if line.strip() and not line.startswith('#'))
+            line_count = sum(
+                1 for line in f if line.strip() and not line.startswith("#")
+            )
         size_mb = os.path.getsize(wordlist_path) / (1024 * 1024)
         # Check if it's a built-in wordlist (from any souleyez location)
         builtin_dirs = [
@@ -321,135 +335,86 @@ def get_wordlist_info(wordlist_path):
         is_builtin = any(bd in wordlist_path for bd in builtin_dirs)
 
         return {
-            'path': wordlist_path,
-            'line_count': line_count,
-            'size_mb': size_mb,
-            'is_builtin': is_builtin
+            "path": wordlist_path,
+            "line_count": line_count,
+            "size_mb": size_mb,
+            "is_builtin": is_builtin,
         }
     except Exception:
         return None
 
 
-def display_wordlist_menu(tool_name, category, title="Wordlist Selection"):
+def display_wordlist_menu(
+    tool_name, category, title="Wordlist Selection", allow_single_value=None
+):
     """
-    Display an interactive wordlist selection menu.
-    
+    Display an interactive wordlist selection browser.
+
+    Goes directly to the full wordlist browser with recommended wordlists highlighted.
+
     Args:
         tool_name: Name of the tool
         category: Category of wordlist
         title: Menu title
-    
+        allow_single_value: If True, enable single value entry. If None (default),
+                           auto-detect based on category (True for users/passwords)
+
     Returns:
-        Selected wordlist path or None if cancelled
+        Selected wordlist path, ('single', value) tuple, or None if cancelled
     """
     import click
-    
+    from souleyez.ui.wordlist_browser import browse_wordlists
+
+    # Get recommended wordlists for this tool/category
     wordlists = get_wordlists(tool_name, category)
-    
-    if not wordlists:
-        click.echo(click.style(f"No wordlists found for {tool_name} {category}", fg='red'))
-        return None
-    
-    click.echo()
-    click.echo(click.style(f"📝 {title}", bold=True, fg='yellow'))
-    click.echo()
-    click.echo("Available wordlists:")
-
-    # Separate built-in and system wordlists
-    # Built-in = under souleyez wordlist directories (user, package, or dev)
+
+    # Separate built-in wordlists (these are recommended)
     builtin_dirs = [
         str(Path.home() / ".souleyez" / "data" / "wordlists"),
         "/usr/share/souleyez/wordlists",
         str(Path(__file__).parent / "data" / "wordlists"),  # Package bundled
     ]
-    builtin = [w for w in wordlists if any(bd in w for bd in builtin_dirs)]
-    system = [w for w in wordlists if w not in builtin]
-    
-    choice_map = {}
-    idx = 1
-    
-    if builtin:
-        click.echo(click.style("  SoulEyez Built-in (Recommended):", fg='cyan', bold=True))
-        for wl in builtin:
-            info = get_wordlist_info(wl)
-            if info:
-                click.echo(f"    {idx}. {wl} ({info['line_count']} entries)")
-                choice_map[idx] = wl
-                idx += 1
-        click.echo()
-    
-    if system:
-        click.echo(click.style("  System Wordlists:", fg='yellow'))
-        for wl in system:
-            info = get_wordlist_info(wl)
-            if info:
-                if info['size_mb'] > 0.1:
-                    click.echo(f"    {idx}. {wl} ({info['size_mb']:.1f} MB)")
-                else:
-                    click.echo(f"    {idx}. {wl} ({info['line_count']} entries)")
-                choice_map[idx] = wl
-                idx += 1
-        click.echo()
-    
-    # Browse all wordlists option
-    click.echo(f"  {idx}. Browse all wordlists...")
-    browse_idx = idx
-    idx += 1
-
-    # Dynamic label based on category
-    single_label = "Enter single username" if category == 'users' else "Enter single password" if category == 'passwords' else "Enter single value"
-
-    click.echo(f"  {idx}. {single_label}")
-    single_idx = idx
-    idx += 1
-    click.echo(f"  {idx}. Enter custom path")
-    custom_idx = idx
-    click.echo(f"  0. Cancel")
-    click.echo()
-
-    try:
-        choice = click.prompt("Select wordlist", type=int, default=1)
-
-        if choice == 0:
-            return None
-        elif choice in choice_map:
-            selected = choice_map[choice]
-            click.echo(click.style(f"✓ Selected: {selected}", fg='green'))
-            return selected
-        elif choice == browse_idx:
-            # Launch interactive wordlist browser
-            from souleyez.ui.wordlist_browser import browse_wordlists
-            selected = browse_wordlists(category_filter=category, title=f'SELECT {category.upper()} WORDLIST')
-            if selected:
-                click.echo(click.style(f"✓ Selected: {selected}", fg='green'))
-            return selected
-        elif choice == single_idx:
-            # Single value entry - return tuple to indicate it's not a file
-            value_prompt = "Enter username" if category == 'users' else "Enter password" if category == 'passwords' else "Enter value"
-            value = click.prompt(value_prompt, type=str)
-            if value.strip():
-                click.echo(click.style(f"✓ Single value: {value.strip()}", fg='green'))
-                return ('single', value.strip())
-            else:
-                click.echo(click.style("✗ Empty value", fg='red'))
-                return None
-        elif choice == custom_idx:
-            custom = click.prompt("Enter custom wordlist path", type=str)
-            import os
-            if os.path.exists(custom):
-                click.echo(click.style(f"✓ Custom wordlist: {custom}", fg='green'))
-                return custom
-            else:
-                click.echo(click.style("✗ File not found", fg='red'))
-                return None
+    recommended = [w for w in wordlists if any(bd in w for bd in builtin_dirs)]
+
+    # Determine single value label based on category
+    single_label = (
+        "username"
+        if category == "users"
+        else "password" if category == "passwords" else "value"
+    )
+
+    # Auto-detect allow_single_value based on category if not specified
+    # Single values make sense for users/passwords but not for dirs/dns wordlists
+    if allow_single_value is None:
+        allow_single_value = category in ("users", "passwords")
+
+    # Launch browser directly with recommended paths highlighted
+    selected = browse_wordlists(
+        category_filter=category,
+        title=(
+            f"SELECT {category.upper()} WORDLIST"
+            if title == "Wordlist Selection"
+            else title.upper()
+        ),
+        recommended_paths=recommended,
+        allow_single_value=allow_single_value,
+        allow_custom_path=True,
+        single_value_label=single_label,
+    )
+
+    # Show confirmation message
+    if selected:
+        if isinstance(selected, tuple) and selected[0] == "single":
+            click.echo(
+                click.style(f"✓ Single {single_label}: {selected[1]}", fg="green")
+            )
         else:
-            click.echo(click.style("Invalid selection", fg='red'))
-            return None
-    except (KeyboardInterrupt, click.Abort):
-        return None
+            click.echo(click.style(f"✓ Selected: {selected}", fg="green"))
+
+    return selected
 
 
-def get_available_wordlists(category='users'):
+def get_available_wordlists(category="users"):
     """
     Get available wordlists for a category.
 
@@ -461,20 +426,20 @@ def get_available_wordlists(category='users'):
     """
     result = {}
 
-    if category == 'users':
+    if category == "users":
         files = [
             ("All Users", "all_users.txt"),
             ("Linux Users", "linux_users.txt"),
             ("Soul Users", "soul_users.txt"),
         ]
-    elif category == 'passwords':
+    elif category == "passwords":
         files = [
             ("Top 20 Quick", "top20_quick.txt"),
             ("Top 100", "top100.txt"),
             ("Soul Passwords", "soul_pass.txt"),
             ("Default Credentials", "default_credentials.txt"),
         ]
-    elif category == 'credentials':
+    elif category == "credentials":
         files = [
             ("Default Credentials (user:pass)", "default_credentials.txt"),
         ]
@@ -488,7 +453,9 @@ def get_available_wordlists(category='users'):
             # Dynamically calculate entry count (excluding comments and blank lines)
             try:
                 with open(resolved) as f:
-                    count = sum(1 for line in f if line.strip() and not line.startswith('#'))
+                    count = sum(
+                        1 for line in f if line.strip() and not line.startswith("#")
+                    )
                 name_with_count = f"{name} ({count})"
             except Exception:
                 name_with_count = name

{souleyez-2.43.28.dist-info → souleyez-2.43.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: souleyez
-Version: 2.43.28
+Version: 2.43.32
 Summary: AI-Powered Penetration Testing Platform with 40+ integrated tools
 Author-email: CyberSoul Security <contact@cybersoulsecurity.com>
 Maintainer-email: CyberSoul Security <contact@cybersoulsecurity.com>