Merge PR

Author: kimocoder

wifite/args.py

@@ -254,6 +254,22 @@ def _add_global_args(self, glob):
                           help=Color.s(
                               'Shows more options ({C}-h -v{W}). Prints commands and outputs. (default: {G}quiet{W})'))
 
+        glob.add_argument('--debug',
+                          action='store_true',
+                          default=False,
+                          dest='debug',
+                          help=self._verbose(
+                              'Shorthand for {C}-vvv{W}: max verbosity with file logging to {C}~/.wifite/wifite.log{W}'))
+
+        glob.add_argument('--log-file',
+                          action='store',
+                          dest='log_file',
+                          metavar='[path]',
+                          type=str,
+                          default=None,
+                          help=self._verbose(
+                              'Write debug log to {C}[path]{W} (implies {C}-vv{W} minimum verbosity)'))
+
         glob.add_argument('-i',
                           action='store',
                           dest='interface',
@@ -366,6 +382,14 @@ def _add_global_args(self, glob):
                           help=self._verbose(
                               'Hides targets with ESSIDs that match the given text. Can be used more than once.'))
         glob.add_argument('--ignore-essid', help=argparse.SUPPRESS, action='append', dest='ignore_essids', type=str)
+        glob.add_argument('--ignore-essids-file',
+                          action='store',
+                          dest='ignore_essids_file',
+                          metavar='[file]',
+                          type=str,
+                          default=None,
+                          help=self._verbose(
+                              'Hides targets whose ESSID appears in {C}[file]{W} (one ESSID per line).'))
 
         glob.add_argument('-ic',
                           '--ignore-cracked',

wifite/attack/all.py

@@ -11,6 +11,7 @@
 from ..config import Configuration
 from ..model.target import WPSState
 from ..util.color import Color
+from ..util.logger import log_info, log_debug
 from ..util.wpa3_tools import WPA3ToolChecker
 from ..util.memory import MemoryMonitor, get_infinite_monitor
 
@@ -82,6 +83,9 @@ def attack_single(cls, target, targets_remaining, session=None, session_mgr=None
         Returns: True if attacks should continue, False otherwise.
         """
         global attack
+        log_info('AttackAll', 'Targeting %s (%s) enc=%s auth=%s wps=%s pwr=%s (%d remaining)' % (
+            target.essid or '(hidden)', target.bssid, target.encryption,
+            target.authentication, target.wps, target.power, targets_remaining))
         if 'MGT' in target.authentication:
             Color.pl("\n{!}{O}Skipping. Target is using {C}WPA-Enterprise {O}and can not be cracked.")
             # Mark as failed in session
@@ -268,7 +272,7 @@ def user_wants_to_continue(cls, targets_remaining, attacks_remaining=0):
             Answer.ExitOrReturn if the user wants to stop the remaining attacks
         """
         if attacks_remaining == 0 and targets_remaining == 0:
-            return  # No targets or attacksleft, drop out
+            return Answer.ExitOrReturn  # No targets or attacks left, drop out
 
         prompt_list = []
         if attacks_remaining > 0:

wifite/attack/wep.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import subprocess
 import time
 
 from ..config import Configuration
@@ -11,6 +12,7 @@
 from ..tools.airodump import Airodump
 from ..tools.ip import Ip
 from ..util.color import Color
+from ..util.logger import log_debug, log_info, log_warning
 from ..util.output import OutputManager
 
 
@@ -42,7 +44,11 @@ def run(self):
             Including airodump-ng starting, cracking, etc.
             Returns: True if attack is successful, false otherwise
         """
-        
+
+        log_info('AttackWEP', 'Starting WEP attack on %s (%s) ch %s' % (
+            self.target.essid or '?', self.target.bssid, self.target.channel))
+        attack_start = time.time()
+
         # Start TUI view if available
         if self.view:
             self.view.start()
@@ -125,9 +131,9 @@ def run(self):
                             client_mac = airodump_target.clients[0].station
 
                         if keep_ivs and current_ivs > airodump_target.ivs:
-                            # We now have less IVS than before; A new attack must have started.
-                            # Track how many we have in-total.
-                            previous_ivs += total_ivs
+                            # We now have less IVs than before; a new attack must have started.
+                            # Save the accumulated total so far before resetting.
+                            previous_ivs = total_ivs
                         current_ivs = airodump_target.ivs
                         total_ivs = previous_ivs + current_ivs
 
@@ -159,6 +165,8 @@ def run(self):
                             Airodump.delete_airodump_temp_files('wep')
 
                             self.success = True
+                            log_info('AttackWEP', 'WEP attack on %s cracked in %.1fs (%d IVs)' % (
+                                self.target.bssid, time.time() - attack_start, total_ivs))
                             return self.success
 
                         if aircrack and aircrack.is_running():
@@ -215,7 +223,7 @@ def run(self):
                                 wep_attack_type = WEPAttackType('forgedreplay')
                                 attack_name = 'forgedreplay'
                                 aireplay = Aireplay(self.target,
-                                                    'forgedreplay',
+                                                    wep_attack_type,
                                                     client_mac=client_mac,
                                                     replay_file=replay_file)
                                 time_unchanged_ivs = time.time()  # Reset unchanged IVs time (it may have taken a
@@ -288,6 +296,8 @@ def run(self):
             Airodump.delete_airodump_temp_files('wep')
 
         self.success = False
+        log_info('AttackWEP', 'WEP attack on %s finished in %.1fs — no key' % (
+            self.target.bssid, time.time() - attack_start))
         return self.success
 
     @staticmethod

wifite/attack/wpa.py

@@ -10,6 +10,7 @@
 from ..util.color import Color
 from ..util.timer import Timer
 from ..util.output import OutputManager
+from ..util.logger import log_debug, log_info, log_warning, log_error
 from ..model.handshake import Handshake
 from ..model.wpa_result import CrackResultWPA
 from ..util.wpasec_uploader import WpaSecUploader
@@ -299,7 +300,12 @@ def _get_interface_assignment(self):
 
     def run(self):
         """Initiates full WPA handshake capture attack."""
-        
+
+        log_info('AttackWPA', 'Starting WPA attack on %s (%s) ch %s pwr %s' % (
+            self.target.essid or '?', self.target.bssid,
+            self.target.channel, self.target.power))
+        self._attack_start_time = time.time()
+
         # Start TUI view if available
         if self.view:
             self.view.start()
@@ -446,6 +452,10 @@ def run(self):
             self.crack_result = CrackResultWPA(handshake.bssid, handshake.essid, handshake.capfile, key)
             self.crack_result.dump()
             self.success = True
+
+        elapsed = time.time() - getattr(self, '_attack_start_time', time.time())
+        log_info('AttackWPA', 'WPA attack on %s finished in %.1fs — %s' % (
+            self.target.bssid, elapsed, 'SUCCESS' if self.success else 'no key'))
         return self.success
 
     def _handle_attack_failure(self, message):

wifite/attack/wpa3.py

@@ -16,6 +16,7 @@
 from ..tools.aireplay import Aireplay
 from ..config import Configuration
 from ..util.color import Color
+from ..util.logger import log_info, log_debug
 from ..util.timer import Timer
 from ..util.output import OutputManager
 from ..util.wpa3 import WPA3Detector, WPA3Info
@@ -71,6 +72,10 @@ def run(self):
         Returns:
             bool: True if attack succeeded, False otherwise
         """
+        log_info('AttackWPA3', 'Starting WPA3 attack on %s (%s) ch %s' % (
+            self.target.essid or '?', self.target.bssid, self.target.channel))
+        attack_start = time.time()
+
         # Check for required WPA3 tools
         if not self._check_wpa3_tools():
             return False
@@ -96,16 +101,21 @@ def run(self):
 
         # Execute strategy based on selection
         if self.attack_strategy == WPA3AttackStrategy.DOWNGRADE:
-            return self._execute_downgrade_strategy()
+            result = self._execute_downgrade_strategy()
         elif self.attack_strategy == WPA3AttackStrategy.DRAGONBLOOD:
-            return self._execute_dragonblood_strategy()
+            result = self._execute_dragonblood_strategy()
         elif self.attack_strategy == WPA3AttackStrategy.SAE_CAPTURE:
-            return self._execute_sae_capture_strategy()
+            result = self._execute_sae_capture_strategy()
         elif self.attack_strategy == WPA3AttackStrategy.PASSIVE:
-            return self._execute_passive_strategy()
+            result = self._execute_passive_strategy()
         else:
             Color.pl('{!} {R}Unknown attack strategy: %s{W}' % self.attack_strategy)
-            return False
+            result = False
+
+        log_info('AttackWPA3', 'WPA3 attack on %s finished in %.1fs — %s' % (
+            self.target.bssid, time.time() - attack_start,
+            'SUCCESS' if result else 'failed'))
+        return result
 
     def _check_wpa3_tools(self):
         """

wifite/attack/wps.py

@@ -1,8 +1,11 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import time
+
 from ..model.attack import Attack
 from ..util.color import Color
+from ..util.logger import log_info, log_debug
 from ..config import Configuration
 from ..util.output import OutputManager
 from ..tools.bully import Bully
@@ -35,7 +38,12 @@ def __init__(self, target, pixie_dust=False, null_pin=False):
 
     def run(self):
         """ Run all WPS-related attacks """
-        
+
+        mode = 'pixie-dust' if self.pixie_dust else ('null-pin' if self.null_pin else 'pin')
+        log_info('AttackWPS', 'Starting WPS %s attack on %s (%s)' % (
+            mode, self.target.essid or '?', self.target.bssid))
+        self._attack_start = time.time()
+
         # Start TUI view if available
         if self.view:
             self.view.start()
@@ -96,6 +104,7 @@ def _handle_wps_skip(self, message):
         return False
 
     def run_bully(self):
+        log_debug('AttackWPS', 'Using bully for WPS attack')
         bully = Bully(self.target, pixie_dust=self.pixie_dust)
         # Pass the view to bully for TUI updates
         if self.view:
@@ -104,14 +113,21 @@ def run_bully(self):
         bully.stop()
         self.crack_result = bully.crack_result
         self.success = self.crack_result is not None
+        log_info('AttackWPS', 'WPS bully attack on %s finished in %.1fs — %s' % (
+            self.target.bssid, time.time() - getattr(self, '_attack_start', time.time()),
+            'SUCCESS' if self.success else 'no pin'))
         return self.success
 
     def run_reaver(self):
+        log_debug('AttackWPS', 'Using reaver for WPS attack')
         reaver = Reaver(self.target, pixie_dust=self.pixie_dust, null_pin=self.null_pin)
         # Pass the view to reaver for TUI updates
         if self.view:
             reaver.attack_view = self.view
         reaver.run()
         self.crack_result = reaver.crack_result
         self.success = self.crack_result is not None
+        log_info('AttackWPS', 'WPS reaver attack on %s finished in %.1fs — %s' % (
+            self.target.bssid, time.time() - getattr(self, '_attack_start', time.time()),
+            'SUCCESS' if self.success else 'no pin'))
         return self.success

wifite/config.py

@@ -719,6 +719,21 @@ def parse_settings_args(cls, args):
             Color.pl('{+} {C}option: {O}ignoring ESSID(s): {R}%s{W}' %
                      ', '.join(args.ignore_essids))
 
+        if args.ignore_essids_file is not None:
+            try:
+                with open(args.ignore_essids_file, 'r', encoding='utf-8', errors='replace') as fh:
+                    file_essids = [line.strip() for line in fh if line.strip() and not line.startswith('#')]
+                if file_essids:
+                    cls.ignore_essids = list(set((cls.ignore_essids or []) + file_essids))
+                    Color.pl('{+} {C}option: {O}ignoring {R}%d{O} ESSID(s) from file {R}%s{W}' %
+                             (len(file_essids), args.ignore_essids_file))
+                else:
+                    Color.pl('{!} {O}ignore-essids-file {R}%s{O} is empty or has only comments{W}' %
+                             args.ignore_essids_file)
+            except (OSError, IOError) as e:
+                Color.pl('{!} {R}Could not read ignore-essids-file {O}%s{R}: %s{W}' %
+                         (args.ignore_essids_file, str(e)))
+
         from .model.result import CrackResult
         cls.ignore_cracked = CrackResult.load_ignored_bssids(args.ignore_cracked)
 
@@ -747,14 +762,28 @@ def parse_settings_args(cls, args):
             Color.pl('{+} {C}option:{W} using {G}classic text mode{W} (TUI disabled)')
         # else: use_tui remains False (classic mode is default)
 
+        # --debug is shorthand for -vvv + file logging
+        if args.debug:
+            args.verbose = max(args.verbose, 3)
+
         if args.verbose:
             cls.verbose = args.verbose
             Color.pl('{+} {C}option:{W} verbosity level {G}%d{W}' % args.verbose)
 
-            # Update logger with verbosity level
+            # Determine log file: explicit --log-file wins, then --debug default, then -vv+ default
             from .util.logger import Logger
-            log_file = os.path.join(os.path.expanduser('~'), '.wifite', 'wifite.log') if args.verbose >= 2 else None
+            log_file = getattr(args, 'log_file', None)
+            if log_file is None and args.verbose >= 2:
+                log_file = os.path.join(os.path.expanduser('~'), '.wifite', 'wifite.log')
+            if log_file:
+                Color.pl('{+} {C}option:{W} logging to {G}%s{W}' % log_file)
             Logger.initialize(log_file=log_file, verbose=args.verbose, enabled=True)
+        elif getattr(args, 'log_file', None):
+            # --log-file without -v: enable at least verbose=2 so the log is useful
+            cls.verbose = max(cls.verbose, 2)
+            from .util.logger import Logger
+            Color.pl('{+} {C}option:{W} logging to {G}%s{W} (verbose level raised to 2)' % args.log_file)
+            Logger.initialize(log_file=args.log_file, verbose=cls.verbose, enabled=True)
 
         if args.kill_conflicting_processes:
             cls.kill_conflicting_processes = True

wifite/model/handshake.py

@@ -3,6 +3,7 @@
 
 from ..util.process import Process
 from ..util.color import Color
+from ..util.logger import log_debug, log_info
 from ..tools.tshark import Tshark
 
 import re
@@ -37,7 +38,7 @@ def divine_bssid_and_essid(self):
             # Tshark failed us, nothing else we can do.
             raise ValueError(f'Cannot find BSSID or ESSID in cap file {self.capfile}')
 
-        if not self.essid and not self.bssid:
+        if not self.essid and not self.bssid and len(pairs) > 0:
             # We do not know the bssid nor the essid
             # TODO: Display menu for user to select from list
             # HACK: Just use the first one we see
@@ -60,18 +61,29 @@ def divine_bssid_and_essid(self):
                     Color.pl('\n{+} Discovered essid "{C}%s{W}"' % essid)
                     self.essid = essid
                     break
+
     def has_handshake(self):
         if not self.bssid or not self.essid:
             self.divine_bssid_and_essid()
 
-        #return len(self.tshark_handshakes()) > 0
+        log_debug('Handshake', 'Checking %s for handshake (bssid=%s essid=%s)' % (
+            self.capfile, self.bssid, self.essid))
+
         # Prefer strict validators. Do NOT accept aircrack alone as proof.
         # Tshark requires the full 4-way (strict) — keep it.
-        if len(self.tshark_handshakes()) > 0:
+        tshark_results = self.tshark_handshakes()
+        if len(tshark_results) > 0:
+            log_info('Handshake', 'tshark confirmed handshake in %s' % self.capfile)
             return True
 
         # cowpatty can be reliable for 2&3 captures
-        return len(self.cowpatty_handshakes()) > 0
+        cowpatty_results = self.cowpatty_handshakes()
+        if len(cowpatty_results) > 0:
+            log_info('Handshake', 'cowpatty confirmed handshake in %s' % self.capfile)
+            return True
+
+        log_debug('Handshake', 'No valid handshake found in %s' % self.capfile)
+        return False
 
     def tshark_handshakes(self):
         """Returns list[tuple] of BSSID & ESSID pairs (ESSIDs are always `None`)."""
@@ -98,20 +110,21 @@ def cowpatty_handshakes(self):
             command.append('-2')
         command.extend([
             '-r', self.capfile,
-            '-c'  # Check for handshake (requires ESSID)
+            '-c',  # Check for handshake
         ])
-        
-        # Add ESSID if available (required for -c option)
+
+        # Add ESSID (required for -c option)
         if self.essid:
-            command.append(self.essid)
+            command.extend(['-s', self.essid])
+        else:
+            return []  # cowpatty -c requires an ESSID
 
         proc = Process(command, devnull=False)
         return next(
             (
                 [(None, self.essid)]
                 for line in proc.stdout().split('\n')
-                if 'Collected all necessary data to '
-                'mount crack against WPA' in line
+                if 'Collected all necessary data to mount crack against WPA' in line
             ),
             [],
         )