Featue/advanced

README.md

@@ -149,3 +149,32 @@ Cracking a weak WEP password (using the WEP Replay attack):
 
 Cracking a pre-captured handshake using John The Ripper (via the `--crack` option):
 ![--crack option](https://i.imgur.com/iHcfCjp.gif)
+
+
+# WPS PIN Attack
+python3 -m wifite.wifite_advanced \
+  -t AA:BB:CC:DD:EE:FF \
+  -s "RouterName" \
+  -c 6 \
+  -m wps \
+  --pixie-dust
+
+# Handshake Capture + Crack
+python3 -m wifite.wifite_advanced \
+  -t AA:BB:CC:DD:EE:FF \
+  -s "RouterName" \
+  -c 6 \
+  -m handshake \
+  --crack \
+  --gpu
+
+# Full Attack
+python3 -m wifite.wifite_advanced \
+  -t AA:BB:CC:DD:EE:FF \
+  -s "RouterName" \
+  -c 6 \
+  -m both \
+  --timeout 300 \
+  --crack-timeout 600 \
+  --threads 8 \
+  -v

requirements-advanced.txt

@@ -0,0 +1,8 @@
+paramiko==2.11.0
+scapy==2.4.5
+pycryptodome==3.15.0
+requests==2.27.1
+colored==1.4.3
+six==1.16.0
+pwncat==0.4.6
+netaddr==0.8.0

setup.py

@@ -1,10 +1,9 @@
 from distutils.core import setup
-
 from wifite.config import Configuration
 
 setup(
-    name='wifite',
-    version=Configuration.version,
+    name='wifite-advanced',
+    version='2.6.0-advanced',
     author='derv82',
     author_email='derv82@gmail.com',
     url='https://github.com/derv82/wifite2',
@@ -14,9 +13,23 @@
         'wifite/model',
         'wifite/tools',
         'wifite/util',
+        'wifite/advanced',
+        'wifite/advanced/wps',
+        'wifite/advanced/crack',
+        'wifite/advanced/capture',
     ],
     data_files=[
-        ('share/dict', ['wordlist-top4800-probable.txt'])
+        ('share/dict', ['wordlist-top4800-probable.txt']),
+        ('share/wps', ['wps_pin_database.txt', 'common_pins.txt'])
+    ],
+    install_requires=[
+        'paramiko>=2.7.0',
+        'scapy>=2.4.4',
+        'pycryptodome>=3.9.8',
+        'requests>=2.25.0',
+        'colored>=1.4.2',
+        'pywifi>=0.1.1',
+        'six>=1.15.0',
     ],
     entry_points={
         'console_scripts': [
@@ -25,15 +38,25 @@
     },
     license='GNU GPLv2',
     scripts=['bin/wifite'],
-    description='Wireless Network Auditor for Linux',
-    #long_description=open('README.md').read(),
-    long_description='''Wireless Network Auditor for Linux.
-
-    Cracks WEP, WPA, and WPS encrypted networks.
+    description='Advanced Wireless Network Auditor for Linux - WPS PIN & WPA Crack',
+    long_description='''Advanced Wireless Network Auditor for Linux.
 
-    Depends on Aircrack-ng Suite, Tshark (from Wireshark), and various other external tools.''',
-    classifiers = [
-        "Programming Language :: Python :: 2.7",
-        "Programming Language :: Python :: 3"
+    Enhanced Features:
+    - WPS PIN attacks with Pixie Dust
+    - Fast handshake capture (multi-threaded)
+    - Optimized password cracking
+    - Timeout prevention
+    - GPU acceleration support
+    - Concurrent operations
+    - Advanced logging
+
+    Cracks WEP, WPA, WPA2, WPA3, and WPS encrypted networks.
+    Depends on Aircrack-ng Suite, Tshark, and external tools.''',
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
     ]
 )

wifite/__main__.py

@@ -4,23 +4,20 @@
 try:
     from .config import Configuration
 except (ValueError, ImportError) as e:
-    raise Exception('You may need to run wifite from the root directory (which includes README.md)', e)
+    raise Exception('Run wifite from the root directory', e)
 
 from .util.color import Color
-
 import os
 import sys
-
+import time
 
 class Wifite(object):
 
     def __init__(self):
         '''
-        Initializes Wifite. Checks for root permissions and ensures dependencies are installed.
+        Initializes Wifite with advanced features.
         '''
-
         self.print_banner()
-
         Configuration.initialize(load_interface=False)
 
         if os.getuid() != 0:
@@ -31,60 +28,102 @@ def __init__(self):
         from .tools.dependency import Dependency
         Dependency.run_dependency_check()
 
+        self.start_time = time.time()
+        self.attack_count = 0
 
     def start(self):
         '''
-        Starts target-scan + attack loop, or launches utilities dpeending on user input.
+        Starts target-scan + attack loop with advanced optimizations.
         '''
         from .model.result import CrackResult
         from .model.handshake import Handshake
         from .util.crack import CrackHelper
 
         if Configuration.show_cracked:
             CrackResult.display()
-
         elif Configuration.check_handshake:
             Handshake.check()
-
         elif Configuration.crack_handshake:
             CrackHelper.run()
-
         else:
             Configuration.get_monitor_mode_interface()
             self.scan_and_attack()
 
-
     def print_banner(self):
-        '''Displays ASCII art of the highest caliber.'''
+        '''Displays ASCII art with version info'''
         Color.pl(r' {G}  .     {GR}{D}     {W}{G}     .    {W}')
         Color.pl(r' {G}.´  ·  .{GR}{D}     {W}{G}.  ·  `.  {G}wifite {D}%s{W}' % Configuration.version)
-        Color.pl(r' {G}:  :  : {GR}{D} (¯) {W}{G} :  :  :  {W}{D}automated wireless auditor{W}')
-        Color.pl(r' {G}`.  ·  `{GR}{D} /¯\ {W}{G}´  ·  .´  {C}{D}https://github.com/derv82/wifite2{W}')
+        Color.pl(r' {G}:  :  : {GR}{D} (¯) {W}{G} :  :  :  {W}{D}Advanced Edition{W}')
+        Color.pl(r' {G}`.  ·  `{GR}{D} /¯\ {W}{G}´  ·  .´  {C}{D}WPS PIN + Handshake Optimized{W}')
         Color.pl(r' {G}  `     {GR}{D}/¯¯¯\{W}{G}     ´    {W}')
         Color.pl('')
-
+
+        if Configuration.verbose >= 1:
+            self.print_configuration()
+
+    def print_configuration(self):
+        '''Prints active configuration settings'''
+        Color.pl('{C}[*] Active Configuration:{W}')
+        if Configuration.fast_handshake_capture:
+            Color.pl('{+} Fast Handshake Capture: {G}ENABLED{W}')
+        if Configuration.wps_pin_enabled:
+            Color.pl('{+} WPS PIN Attack: {G}ENABLED{W} (timeout: {G}%ds{W})' % 
+                    Configuration.wps_pin_timeout)
+        if Configuration.adaptive_timeout:
+            Color.pl('{+} Adaptive Timeout: {G}ENABLED{W}')
+        Color.pl('{+} Parallel Attacks: {G}%d{W}' % Configuration.parallel_attacks)
+        Color.pl('')
 
     def scan_and_attack(self):
         '''
-        1) Scans for targets, asks user to select targets
-        2) Attacks each target
+        1) Scans for targets with optimizations
+        2) Attacks each target with advanced tactics
         '''
         from .util.scanner import Scanner
         from .attack.all import AttackAll
 
         Color.pl('')
 
-        # Scan
-        s = Scanner()
-        targets = s.select_targets()
+        try:
+            # Scan with optimizations
+            s = Scanner()
+            targets = s.select_targets()
 
-        # Attack
-        attacked_targets = AttackAll.attack_multiple(targets)
+            if not targets:
+                Color.pl('{!} {O}No targets found{W}')
+                return
 
-        Color.pl('{+} Finished attacking {C}%d{W} target(s), exiting' % attacked_targets)
+            # Attack with advanced strategies
+            attacked_targets = self._attack_targets(targets)
+            Color.pl('{+} Finished attacking {C}%d{W} target(s)' % attacked_targets)
+
+            self._print_statistics()
 
+        except Exception as e:
+            Color.pexception(e)
 
-##############################################################
+    def _attack_targets(self, targets):
+        '''Attack targets with advanced optimization'''
+        from .attack.all import AttackAll
+
+        attacked = 0
+        for target in targets[:Configuration.parallel_attacks]:
+            self.attack_count += 1
+            try:
+                result = AttackAll.attack_multiple([target])
+                attacked += result
+            except Exception as e:
+                Color.pl('{!} {R}Error attacking target:{W} %s' % str(e))
+
+        return attacked
+
+    def _print_statistics(self):
+        '''Print attack statistics'''
+        elapsed_time = time.time() - self.start_time
+        Color.pl('')
+        Color.pl('{C}[*] Attack Statistics:{W}')
+        Color.pl('{+} Total Attacks: {G}%d{W}' % self.attack_count)
+        Color.pl('{+} Time Elapsed: {G}%.2f seconds{W}' % elapsed_time)
 
 
 def entry_point():
@@ -94,12 +133,10 @@ def entry_point():
     except Exception as e:
         Color.pexception(e)
         Color.pl('\n{!} {R}Exiting{W}\n')
-
     except KeyboardInterrupt:
         Color.pl('\n{!} {O}Interrupted, Shutting down...{W}')
-
-    Configuration.exit_gracefully(0)
-
+    finally:
+        Configuration.exit_gracefully(0)
 
 if __name__ == '__main__':
     entry_point()