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

souleyez/plugins/hashcat.py

@@ -49,41 +49,41 @@ HELP = {
             {
                 "name": "NTLM Fast",
                 "args": ["-m", "1000", "-a", "0", "--workload-profile", "3"],
-                "desc": "Crack Windows NTLM hashes (fast dictionary)"
+                "desc": "Crack Windows NTLM hashes (fast dictionary)",
             },
             {
                 "name": "NTLM with Rules",
                 "args": ["-m", "1000", "-a", "0", "-r", "rules/best64.rule"],
-                "desc": "Crack NTLM with best64 rules"
+                "desc": "Crack NTLM with best64 rules",
             },
             {
                 "name": "NetNTLMv2",
                 "args": ["-m", "5600", "-a", "0"],
-                "desc": "Crack NetNTLMv2 hashes"
+                "desc": "Crack NetNTLMv2 hashes",
             },
         ],
         "linux": [
             {
                 "name": "SHA-512 (shadow)",
                 "args": ["-m", "1800", "-a", "0"],
-                "desc": "Crack Linux SHA-512 shadow hashes"
+                "desc": "Crack Linux SHA-512 shadow hashes",
             },
             {
                 "name": "MD5 (shadow)",
                 "args": ["-m", "500", "-a", "0"],
-                "desc": "Crack Linux MD5 shadow hashes"
+                "desc": "Crack Linux MD5 shadow hashes",
             },
         ],
         "web": [
             {
                 "name": "MD5",
                 "args": ["-m", "0", "-a", "0"],
-                "desc": "Crack raw MD5 hashes"
+                "desc": "Crack raw MD5 hashes",
             },
             {
                 "name": "bcrypt",
                 "args": ["-m", "3200", "-a", "0"],
-                "desc": "Crack bcrypt hashes (slow)"
+                "desc": "Crack bcrypt hashes (slow)",
             },
         ],
     },
@@ -95,114 +95,139 @@ HELP = {
         "Use hashcat --example-hashes to see hash formats",
         "Cracked results automatically imported to credentials",
     ],
-    "category": "auxiliary"
+    "category": "auxiliary",
 }
 
 # Flatten presets
-for category_presets in HELP['preset_categories'].values():
-    HELP['presets'].extend(category_presets)
+for category_presets in HELP["preset_categories"].values():
+    HELP["presets"].extend(category_presets)
 
 HELP["help_sections"] = [
     {
         "title": "What is Hashcat?",
         "color": "cyan",
         "content": [
-            {"title": "Overview", "desc": "Hashcat is the world's fastest password cracker, supporting 300+ hash types with GPU acceleration for maximum speed."},
-            {"title": "Use Cases", "desc": "Crack password hashes from various sources", "tips": [
-                "Windows NTLM hashes (mode 1000)",
-                "Linux shadow files (mode 1800 for SHA-512)",
-                "NetNTLMv2 from Responder (mode 5600)",
-                "Kerberos TGS-REP (mode 13100)"
-            ]}
-        ]
+            {
+                "title": "Overview",
+                "desc": "Hashcat is the world's fastest password cracker, supporting 300+ hash types with GPU acceleration for maximum speed.",
+            },
+            {
+                "title": "Use Cases",
+                "desc": "Crack password hashes from various sources",
+                "tips": [
+                    "Windows NTLM hashes (mode 1000)",
+                    "Linux shadow files (mode 1800 for SHA-512)",
+                    "NetNTLMv2 from Responder (mode 5600)",
+                    "Kerberos TGS-REP (mode 13100)",
+                ],
+            },
+        ],
     },
     {
         "title": "How to Use",
         "color": "green",
         "content": [
-            {"title": "Basic Workflow", "desc": "1. Identify hash type (--example-hashes)\n     2. Start with dictionary attack (-a 0)\n     3. Apply rules for mutations (-r rules/best64.rule)\n     4. Use --show to see cracked passwords"},
-            {"title": "Attack Modes", "desc": "Different cracking strategies", "tips": [
-                "Dictionary: -a 0 (fastest, use wordlists)",
-                "Combinator: -a 1 (combine two wordlists)",
-                "Mask: -a 3 (brute-force with patterns)",
-                "Rules: -r to mutate dictionary words"
-            ]}
-        ]
+            {
+                "title": "Basic Workflow",
+                "desc": "1. Identify hash type (--example-hashes)\n     2. Start with dictionary attack (-a 0)\n     3. Apply rules for mutations (-r rules/best64.rule)\n     4. Use --show to see cracked passwords",
+            },
+            {
+                "title": "Attack Modes",
+                "desc": "Different cracking strategies",
+                "tips": [
+                    "Dictionary: -a 0 (fastest, use wordlists)",
+                    "Combinator: -a 1 (combine two wordlists)",
+                    "Mask: -a 3 (brute-force with patterns)",
+                    "Rules: -r to mutate dictionary words",
+                ],
+            },
+        ],
     },
     {
         "title": "Tips & Best Practices",
         "color": "yellow",
         "content": [
-            ("Best Practices:", [
-                "GPU is 100x+ faster than CPU",
-                "Start with dictionary, then rules, then masks",
-                "Use --show to check progress",
-                "NTLM is fast to crack (billions/sec on GPU)",
-                "bcrypt is very slow (security feature)"
-            ]),
-            ("Common Issues:", [
-                "No GPU detected: Install correct drivers (CUDA/ROCm)",
-                "Out of memory: Reduce wordlist size or use -w lower",
-                "Wrong format: Verify hash type with --example-hashes",
-                "Too slow: bcrypt/scrypt are intentionally slow"
-            ])
-        ]
-    }
+            (
+                "Best Practices:",
+                [
+                    "GPU is 100x+ faster than CPU",
+                    "Start with dictionary, then rules, then masks",
+                    "Use --show to check progress",
+                    "NTLM is fast to crack (billions/sec on GPU)",
+                    "bcrypt is very slow (security feature)",
+                ],
+            ),
+            (
+                "Common Issues:",
+                [
+                    "No GPU detected: Install correct drivers (CUDA/ROCm)",
+                    "Out of memory: Reduce wordlist size or use -w lower",
+                    "Wrong format: Verify hash type with --example-hashes",
+                    "Too slow: bcrypt/scrypt are intentionally slow",
+                ],
+            ),
+        ],
+    },
 ]
 
 
 class HashcatPlugin(PluginBase):
     """Hashcat password cracking plugin."""
-    
+
     name = "hashcat"
     tool = "hashcat"
     category = "credential_access"
     HELP = HELP
 
-
-    def build_command(self, target: str, args: List[str] = None, label: str = "", log_path: str = None):
+    def build_command(
+        self, target: str, args: List[str] = None, label: str = "", log_path: str = None
+    ):
         """Build command for background execution with PID tracking."""
         if not target:
             if log_path:
-                with open(log_path, 'w') as f:
+                with open(log_path, "w") as f:
                     f.write("ERROR: Hash file path is required\n")
             return None
-        
+
         # Validate hash file exists
         if not os.path.isfile(target):
             if log_path:
-                with open(log_path, 'w') as f:
+                with open(log_path, "w") as f:
                     f.write(f"ERROR: Hash file not found: {target}\n")
             return None
-        
+
         args = args or []
-        
+
         # Hashcat syntax: hashcat [options] hashfile [wordlist]
         # Insert hashfile before wordlist (last positional arg)
         args_list = args if isinstance(args, list) else args.split()
-        
+
         # Find last argument that looks like a file path (wordlist)
         wordlist_idx = None
         for i in range(len(args_list) - 1, -1, -1):
             arg = args_list[i]
-            if not arg.startswith('-') and ('/' in arg or os.path.isfile(arg)):
+            if not arg.startswith("-") and ("/" in arg or os.path.isfile(arg)):
                 wordlist_idx = i
                 break
-        
+
         if wordlist_idx is not None:
-            cmd = ["hashcat"] + args_list[:wordlist_idx] + [target] + args_list[wordlist_idx:]
+            cmd = (
+                ["hashcat"]
+                + args_list[:wordlist_idx]
+                + [target]
+                + args_list[wordlist_idx:]
+            )
         else:
             cmd = ["hashcat"] + args_list + [target]
-        
-        return {
-            'cmd': cmd,
-            'timeout': 7200
-        }
 
-    def run(self, target: str, args: List[str] = None, label: str = "", log_path: str = None) -> int:
+        return {"cmd": cmd, "timeout": 7200}
+
+    def run(
+        self, target: str, args: List[str] = None, label: str = "", log_path: str = None
+    ) -> int:
         """
         Execute hashcat and write output to log_path.
-        
+
         Note: 'target' is used as the hash file path for this plugin.
         """
         if not target:
@@ -211,7 +236,7 @@ class HashcatPlugin(PluginBase):
         # Validate hash file exists
         if not os.path.isfile(target):
             if log_path:
-                with open(log_path, 'w') as f:
+                with open(log_path, "w") as f:
                     f.write(f"ERROR: Hash file not found: {target}\n")
             return 1
 
@@ -223,24 +248,29 @@ class HashcatPlugin(PluginBase):
         # Need to insert hashfile before the wordlist (last positional arg)
         # Find the last non-option argument that looks like a file path (wordlist)
         args_list = args if isinstance(args, list) else args.split()
-        
+
         # Find last argument that looks like a file path (contains / or is a file)
         wordlist_idx = None
         for i in range(len(args_list) - 1, -1, -1):
             arg = args_list[i]
-            if not arg.startswith('-') and ('/' in arg or os.path.isfile(arg)):
+            if not arg.startswith("-") and ("/" in arg or os.path.isfile(arg)):
                 wordlist_idx = i
                 break
-        
+
         if wordlist_idx is not None:
             # Insert hashfile before wordlist
-            cmd = ["hashcat"] + args_list[:wordlist_idx] + [target] + args_list[wordlist_idx:]
+            cmd = (
+                ["hashcat"]
+                + args_list[:wordlist_idx]
+                + [target]
+                + args_list[wordlist_idx:]
+            )
         else:
             # No wordlist found, append hashfile at end
             cmd = ["hashcat"] + args_list + [target]
 
         if log_path:
-            with open(log_path, 'w') as f:
+            with open(log_path, "w") as f:
                 f.write(f"# Hashcat password cracking\n")
                 f.write(f"# Hash file: {target}\n")
                 f.write(f"# Args input: {args}\n")
@@ -251,14 +281,11 @@ class HashcatPlugin(PluginBase):
 
         try:
             result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                timeout=3600  # 1 hour timeout
+                cmd, capture_output=True, text=True, timeout=3600  # 1 hour timeout
             )
 
             if log_path:
-                with open(log_path, 'a') as f:
+                with open(log_path, "a") as f:
                     f.write(result.stdout)
                     if result.stderr:
                         f.write(f"\n\n# Errors:\n{result.stderr}\n")
@@ -267,12 +294,12 @@ class HashcatPlugin(PluginBase):
 
         except subprocess.TimeoutExpired:
             if log_path:
-                with open(log_path, 'a') as f:
+                with open(log_path, "a") as f:
                     f.write("\n\n# ERROR: Command timed out after 1 hour\n")
             return 124
         except Exception as e:
             if log_path:
-                with open(log_path, 'a') as f:
+                with open(log_path, "a") as f:
                     f.write(f"\n\n# ERROR: {str(e)}\n")
             return 1