process: improved process and thread handling significant

Author: kimocoder

wifite/attack/all.py

@@ -223,7 +223,12 @@ def user_wants_to_continue(cls, targets_remaining, attacks_remaining=0):
             prompt += ' or {R}exit{W} %s? {C}' % options
 
         Color.p(prompt)
-        answer = input().lower()
+        try:
+            answer = input().lower()
+        except KeyboardInterrupt:
+            # If user presses Ctrl+C during input, default to exit
+            Color.pl('\n{!} {O}Interrupted during input, exiting...{W}')
+            return Answer.ExitOrReturn
 
         if answer.startswith('s'):
             return Answer.Skip

wifite/attack/pmkid.py

@@ -136,7 +136,11 @@ def run_aircrack(self):
 
             Color.clear_entire_line()
             Color.pattack('WPA', self.target, 'PMKID capture', 'Waiting for target to appear...')
-            airodump_target = self.wait_for_target(airodump)
+            try:
+                airodump_target = self.wait_for_target(airodump)
+            except Exception as e:
+                Color.pl('\n{!} {R}Target timeout:{W} %s' % str(e))
+                return None
 
             # # Try to load existing handshake
             # if Configuration.ignore_old_handshakes == False:
@@ -286,8 +290,7 @@ def crack_pmkid_file(self, pmkid_file):
         if Configuration.wordlist is None:
             Color.pl('\n{!} {O}Not cracking PMKID because there is no {R}wordlist{O} (re-run with {C}--dict{O})')
 
-            # TODO: Uncomment once --crack is updated to support recracking PMKIDs.
-            # Color.pl('{!} {O}Run Wifite with the {R}--crack{O} and {R}--dict{O} options to try again.')
+            Color.pl('{!} {O}Run Wifite with the {R}--crack{O} and {R}--dict{O} options to try again.')
 
             key = None
         else:

wifite/attack/wep.py

@@ -61,7 +61,11 @@ def run(self):
 
                     Color.clear_line()
                     Color.p('\r{+} {O}waiting{W} for target to appear...')
-                    airodump_target = self.wait_for_target(airodump)
+                    try:
+                        airodump_target = self.wait_for_target(airodump)
+                    except Exception as e:
+                        Color.pl('\n{!} {R}Target timeout:{W} %s' % str(e))
+                        break
 
                     fakeauth_proc = None
                     if self.fake_auth():
@@ -95,7 +99,11 @@ def run(self):
 
                     # Loop until attack completes.
                     while True:
-                        airodump_target = self.wait_for_target(airodump)
+                        try:
+                            airodump_target = self.wait_for_target(airodump)
+                        except Exception as e:
+                            Color.pl('\n{!} {R}Target timeout:{W} %s' % str(e))
+                            break
 
                         if client_mac is None and len(airodump_target.clients) > 0:
                             client_mac = airodump_target.clients[0].station

wifite/attack/wpa.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 from ..model.attack import Attack
-from ..tools.aircrack import Aircrack # Still used for other things like WEP
+from ..tools.aircrack import Aircrack
 from ..tools.hashcat import Hashcat
 from ..tools.airodump import Airodump
 from ..tools.aireplay import Aireplay
@@ -72,7 +72,7 @@ def run(self):
         cracker = "Hashcat" # Default to Hashcat
         # TODO: Potentially add a fallback or user choice for aircrack-ng for non-SAE?
         # For now, transitioning WPA/WPA2 cracking to Hashcat as well for consistency,
-        # as Hashcat mode 2500 (hccapx) is generally preferred over aircrack-ng.
+        # as Hashcat mode 22000 (hccapx) is generally preferred over aircrack-ng.
         # Aircrack.crack_handshake might be removed or kept for WEP only in future.
 
         Color.pl(f'\n{{+}} {{C}}Cracking {"WPA3-SAE" if target_is_wpa3_sae else "WPA/WPA2"} Handshake:{{W}} Running {{C}}{cracker}{{W}} with '
@@ -112,7 +112,11 @@ def capture_handshake(self):
 
             Color.clear_entire_line()
             Color.pattack('WPA', self.target, 'Handshake capture', 'Waiting for target to appear...')
-            airodump_target = self.wait_for_target(airodump)
+            try:
+                airodump_target = self.wait_for_target(airodump)
+            except Exception as e:
+                Color.pl('\n{!} {R}Target timeout:{W} %s' % str(e))
+                return None
 
             self.clients = []
 
@@ -181,7 +185,11 @@ def capture_handshake(self):
                 os.remove(temp_file)
 
                 # Look for new clients
-                airodump_target = self.wait_for_target(airodump)
+                try:
+                    airodump_target = self.wait_for_target(airodump)
+                except Exception as e:
+                    Color.pl('\n{!} {R}Target timeout:{W} %s' % str(e))
+                    break  # Exit the capture loop
                 for client in airodump_target.clients:
                     if client.station not in self.clients:
                         Color.clear_entire_line()

wifite/model/attack.py

@@ -23,7 +23,7 @@ def wait_for_target(self, airodump):
         while len(targets) == 0:
             # Wait for target to appear in airodump.
             if int(time.time() - start_time) > Attack.target_wait:
-                raise Exception(f'Target did not appear after {Attack.target_wait:d} seconds, stopping')
+                raise Exception(f'Target did not appear after {Attack.target_wait:d} seconds, target may be out of range or turned off')
             time.sleep(1)
             targets = airodump.get_targets()
             continue

wifite/tools/bully.py

@@ -73,7 +73,11 @@ def run(self):
                       output_file_prefix='wps_pin') as airodump:
             # Wait for target
             self.pattack('Waiting for target to appear...')
-            self.target = self.wait_for_target(airodump)
+            try:
+                self.target = self.wait_for_target(airodump)
+            except Exception as e:
+                self.pattack('{R}Failed: {O}Target timeout: %s{W}' % str(e), newline=True)
+                return self.crack_result is not None
 
             # Start bully
             self.bully_proc = Process(self.cmd,

wifite/tools/reaver.py

@@ -101,7 +101,11 @@ def _run(self):
 
             # Wait for target
             self.pattack('Waiting for target to appear...')
-            self.target = self.wait_for_target(airodump)
+            try:
+                self.target = self.wait_for_target(airodump)
+            except Exception as e:
+                self.pattack('{R}Failed: {O}Target timeout: %s{W}' % str(e), newline=True)
+                return self.crack_result is not None
 
             # Start reaver
             self.reaver_proc = Process(self.reaver_cmd,
@@ -115,7 +119,11 @@ def _run(self):
             while self.crack_result is None and self.reaver_proc.poll() is None:
 
                 # Refresh target information (power)
-                self.target = self.wait_for_target(airodump)
+                try:
+                    self.target = self.wait_for_target(airodump)
+                except Exception as e:
+                    self.pattack('{R}Failed: {O}Target timeout: %s{W}' % str(e), newline=True)
+                    break
 
                 # Update based on reaver output
                 stdout = self.get_output()

wifite/util/process.py

@@ -7,6 +7,7 @@
 import os
 import atexit
 import threading
+import subprocess
 from subprocess import Popen, PIPE
 from ..util.color import Color
 from ..config import Configuration
@@ -213,9 +214,18 @@ def stdin(self, text):
     def get_output(self):
         """ Waits for process to finish, sets stdout & stderr """
         if self.pid.poll() is None:
-            self.pid.wait()
+            try:
+                self.pid.wait(timeout=30)  # 30 second timeout
+            except subprocess.TimeoutExpired:
+                # Force kill if process doesn't finish in time
+                self.force_kill()
         if self.out is None:
-            (self.out, self.err) = self.pid.communicate()
+            try:
+                (self.out, self.err) = self.pid.communicate(timeout=10)  # 10 second timeout
+            except subprocess.TimeoutExpired:
+                # Force kill and get partial output
+                self.force_kill()
+                (self.out, self.err) = self.pid.communicate()
 
         if type(self.out) is bytes:
             self.out = self.out.decode('utf-8')

wifite/util/scanner.py

@@ -96,7 +96,12 @@ def _extracted_from_find_targets_50(self):
         self.print_targets()
         Color.clear_entire_line()
         Color.p(prompt)
-        answer = input().lower()
+        try:
+            answer = input().lower()
+        except KeyboardInterrupt:
+            # If user presses Ctrl+C during input, default to exit
+            Color.pl('\n{!} {O}Interrupted during input, exiting...{W}')
+            return False  # Exit
 
         return not answer.startswith('e')
 
@@ -283,7 +288,14 @@ def _prompt_user_for_targets(self):
         chosen_targets = []
 
         Color.p(input_str)
-        for choice in input().split(','):
+        try:
+            user_input = input()
+        except KeyboardInterrupt:
+            # If user presses Ctrl+C during input, return empty list to exit
+            Color.pl('\n{!} {O}Interrupted during target selection, exiting...{W}')
+            return []
+
+        for choice in user_input.split(','):
             choice = choice.strip()
             if choice.lower() == 'all':
                 chosen_targets = self.targets

wifite/wifite.py

@@ -85,11 +85,13 @@ def scan_and_attack():
 
         Color.pl('')
 
-        # Scan
+        # Scan (no signal handler during scanning to allow proper target selection)
         s = Scanner()
         do_continue = s.find_targets()
         targets = s.select_targets()
 
+        # Attack modules handle KeyboardInterrupt properly, no global handler needed
+
         if Configuration.infinite_mode:
             while do_continue:
                 AttackAll.attack_multiple(targets)
@@ -105,6 +107,14 @@ def scan_and_attack():
         Color.pl('{+} Finished attacking {C}%d{W} target(s), exiting' % attacked_targets)
 
 
+
+
+def force_exit_handler(signum, frame):
+    """Force exit on multiple Ctrl+C during cleanup"""
+    import sys
+    print('\n[!] Force exiting...')
+    sys.exit(1)
+
 def main():
     try:
         wifite = Wifite()
@@ -120,23 +130,66 @@ def main():
         Color.pl('\n{!} {R}Try running with sudo{W}\n')
     except KeyboardInterrupt:
         Color.pl('\n{!} {O}Interrupted, Shutting down...{W}')
+        # Set up force exit handler for cleanup phase
+        import signal
+        signal.signal(signal.SIGINT, force_exit_handler)
     except Exception as e:
         Color.pl('\n{!} {R}Unexpected Error{W}: %s' % str(e))
         Color.pexception(e)
         Color.pl('\n{!} {R}Exiting{W}\n')
 
     finally:
-        # Ensure all processes are cleaned up
-        from .util.process import ProcessManager
-        ProcessManager().cleanup_all()
+        # Set up aggressive force exit handler during cleanup
+        import signal
+        import sys
+
+        def emergency_exit(signum, frame):
+            print('\n[!] Emergency exit!')
+            # Disable atexit callbacks and suppress stderr to prevent ugly exception messages
+            import atexit
+            import os
+            atexit._clear()
+            # Redirect stderr to devnull to hide any remaining cleanup exceptions
+            os.dup2(os.open(os.devnull, os.O_WRONLY), 2)
+            sys.exit(1)
+
+        signal.signal(signal.SIGINT, emergency_exit)
+
+        # Quick cleanup with short timeouts
+        try:
+            from .util.process import ProcessManager
+            import threading
+
+            # Run cleanup in thread with timeout
+            cleanup_thread = threading.Thread(target=ProcessManager().cleanup_all)
+            cleanup_thread.daemon = True
+            cleanup_thread.start()
+            cleanup_thread.join(timeout=3)  # 3 second timeout
+        except:
+            pass  # Ignore cleanup errors
 
-        # Delete Reaver .pcap
+        # Delete Reaver .pcap quickly
         try:
-            subprocess.run(["rm", "reaver_output.pcap"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            subprocess.run(["rm", "-f", "reaver_output.pcap"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=2)
+        except:
+            pass
+
+        # Try graceful exit with timeout
+        try:
+            import threading
+
+            def graceful_exit():
+                Configuration.exit_gracefully()
+
+            exit_thread = threading.Thread(target=graceful_exit)
+            exit_thread.daemon = True
+            exit_thread.start()
+            exit_thread.join(timeout=2)  # 2 second timeout
         except:
-            pass  # Ignore if file doesn't exist
+            pass
 
-        Configuration.exit_gracefully()
+        # Force exit regardless
+        sys.exit(0)
 
 
 if __name__ == '__main__':