Massive refactor/renaming. No more upper-case filenames.

wifite/model/attack.py

@@ -0,0 +1,47 @@
+#!/usr/bin/python2.7
+# -*- coding: utf-8 -*-
+
+import time
+
+class Attack(object):
+    '''
+        Contains functionality common to all attacks
+    '''
+
+    target_wait = 20
+
+    def __init__(self, target):
+        self.target = target
+
+    def run(self):
+        raise Exception("Unimplemented method: run")
+
+    def wait_for_target(self, airodump):
+        '''
+            Waits for target to appear in airodump
+        '''
+        start_time = time.time()
+        targets = airodump.get_targets(apply_filter=False)
+        while len(targets) == 0:
+            # Wait for target to appear in airodump.
+            if int(time.time() - start_time) > Attack.target_wait:
+                raise Exception(
+                    "Target did not appear after %d seconds, stopping"
+                    % Attack.target_wait)
+            time.sleep(1)
+            targets = airodump.get_targets()
+            continue
+
+        # Ensure this target was seen by airodump
+        airodump_target = None
+        for t in targets:
+            if t.bssid == self.target.bssid:
+                airodump_target = t
+                break
+
+        if airodump_target is None:
+            raise Exception(
+                'Could not find target (%s) in airodump' % self.target.bssid)
+
+        return airodump_target
+

wifite/model/client.py

@@ -0,0 +1,42 @@
+#!/usr/bin/python2.7
+# -*- coding: utf-8 -*-
+
+class Client(object):
+    '''
+        Holds details for a "Client" - a wireless device (e.g. computer)
+        that is associated with an Access Point (e.g. router)
+    '''
+
+    def __init__(self, fields):
+        '''
+            Initializes & stores client info based on fields.
+            Args:
+                Fields - List of strings
+                INDEX KEY
+                    0 Station MAC (client's MAC address)
+                    1 First time seen,
+                    2 Last time seen,
+                    3 Power,
+                    4 # packets,
+                    5 BSSID, (Access Point's MAC address)
+                    6 Probed ESSIDs
+        '''
+        self.station =     fields[0].strip()
+        self.power   = int(fields[3].strip())
+        self.packets = int(fields[4].strip())
+        self.bssid   =     fields[5].strip()
+
+
+    def __str__(self):
+        ''' String representation of a Client '''
+        result = ''
+        for (key,value) in self.__dict__.iteritems():
+            result += key + ': ' + str(value)
+            result += ', '
+        return result
+
+
+if __name__ == '__main__':
+    fields = 'AA:BB:CC:DD:EE:FF, 2015-05-27 19:43:47, 2015-05-27 19:43:47, -67,        2, (not associated) ,HOME-ABCD'.split(',')
+    c = Client(fields)
+    print c

wifite/model/handshake.py

@@ -0,0 +1,366 @@
+#!/usr/bin/python2.7
+# -*- coding: utf-8 -*-
+
+from ..util.process import Process
+from ..util.color import Color
+
+import re
+import os
+
+class Handshake(object):
+    def __init__(self, capfile, bssid=None, essid=None):
+        self.capfile = capfile
+        self.bssid = bssid
+        self.essid = essid
+
+    def divine_bssid_and_essid(self):
+        '''
+            Tries to find BSSID and ESSID from cap file.
+            Sets this instances 'bssid' and 'essid' instance fields.
+         '''
+        # Get list of bssid/essid pairs from cap file
+        pairs = self.tshark_bssid_essid_pairs()
+        if len(pairs) == 0:
+            # Find bssid/essid pairs that have handshakes in Pyrit
+            pairs = self.pyrit_handshakes()
+
+        if len(pairs) == 0 and not self.bssid and not self.essid:
+            # Tshark and Pyrit failed us, nothing else we can do.
+            raise Exception("Cannot find BSSID or ESSID in cap file")
+
+        if not self.essid and not self.bssid:
+            # 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
+            self.bssid = pairs[0][0]
+            self.essid = pairs[0][1]
+            Color.pl('{!} {O}Warning{W}:' +
+                ' {O}Arbitrarily selected' +
+                ' {R}bssid{O} {C}%s{O} and {R}essid{O} "{C}%s{O}"{W}'
+                    % (self.bssid, self.essid))
+
+        elif not self.bssid:
+            # We already know essid
+            for (bssid, essid) in pairs:
+                if self.essid == essid:
+                    Color.pl('{+} Discovered bssid {C}%s{W}' % bssid)
+                    self.bssid = bssid
+                    break
+
+        elif not self.essid:
+            # We already know bssid
+            for (bssid, essid) in pairs:
+                if self.bssid.lower() == bssid.lower():
+                    Color.pl('{+} 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()
+
+        if len(self.tshark_handshakes()) > 0:
+            return True
+
+        if len(self.pyrit_handshakes()) > 0:
+            return True
+
+
+        # XXX: Disabling these checks since I don't think they are reliable.
+        '''
+        if len(self.cowpatty_handshakes()) > 0:
+            return True
+        if len(self.aircrack_handshakes()) > 0:
+            return True
+        '''
+        return False
+
+
+    def tshark_bssid_essid_pairs(self):
+        '''
+            Scrapes capfile for beacon frames indicating the ESSID.
+            Returns list of tuples: (bssid,essid)
+        '''
+        if not Process.exists('tshark'):
+            raise Exception('tshark is required to find ESSID')
+
+        essids = set()
+
+        # Extract beacon frames from cap file
+        cmd = [
+            'tshark',
+            '-r', self.capfile,
+            '-R', 'wlan.fc.type_subtype == 0x08 || wlan.fc.type_subtype == 0x05',
+            '-2', # tshark: -R without -2 is deprecated.
+            '-n'
+        ]
+        proc = Process(cmd, devnull=False)
+        for line in proc.stdout().split('\n'):
+            # Extract src, dst, and essid
+            mac_regex = ('[a-zA-Z0-9]{2}:' * 6)[:-1]
+            match = re.search('(%s) [^ ]* (%s).*.*SSID=(.*)$'
+                % (mac_regex, mac_regex), line)
+            if match is None:
+                # Line doesn't contain src, dst, ssid
+                continue
+            (src, dst, essid) = match.groups()
+            if dst.lower() == "ff:ff:ff:ff:ff:ff": continue
+            if self.bssid:
+                # We know the BSSID, only return the ESSID for this BSSID.
+                if self.bssid.lower() == src.lower() or self.bssid.lower() == dst.lower():
+                    essids.add((src, essid))
+            else:
+                # We do not know BSSID, add it.
+                essids.add((src, essid))
+        # Return list of tuples
+        return [x for x in essids]
+
+
+    def tshark_command(self):
+        return [
+            'tshark',
+            '-r', self.capfile,
+            '-R', 'eapol',
+            '-n',
+            '-2' # 2-pass filtering, required when using -R in newer versions of tshark
+        ]
+
+    def tshark_handshakes(self):
+        ''' Returns True if tshark identifies a handshake, False otherwise '''
+        if not Process.exists('tshark'):
+            return []
+
+        target_client_msg_nums = {}
+
+        # Dump EAPOL packets
+        proc = Process(self.tshark_command(), devnull=False)
+        for line in proc.stdout().split('\n'):
+            # Extract source mac, destination mac, and message numbers
+            mac_regex = ('[a-zA-Z0-9]{2}:' * 6)[:-1]
+            match = re.search('(%s) (?:->|→) (%s).*Message.*(\d).*(\d)'
+                % (mac_regex, mac_regex), line)
+            if match is None:
+                # Line doesn't contain src, dst, Message numbers
+                continue
+            (src, dst, index, ttl) = match.groups()
+            # "Message (index) of (ttl)"
+            index = int(index)
+            ttl = int(ttl)
+
+            if ttl != 4:
+                # Must be a 4-way handshake
+                continue
+
+            # Identify the client and target MAC addresses
+            if index % 2 == 1:
+                # First and Third messages
+                target = src
+                client = dst
+            else:
+                # Second and Fourth messages
+                client = src
+                target = dst
+
+            if self.bssid and self.bssid.lower() != target.lower():
+                # We know the BSSID and this msg was not for the target
+                continue
+
+            target_client_key = '%s,%s' % (target, client)
+
+            # Ensure all 4 messages are:
+            # Between the same client and target
+            # In numeric & chronological order (1,2,3,4)
+            if index == 1:
+                # First message, add to dict
+                target_client_msg_nums[target_client_key] = 1
+
+            elif target_client_key not in target_client_msg_nums:
+                # Not first message, we haven't gotten the first message yet
+                continue
+
+            elif index - 1 != target_client_msg_nums[target_client_key]:
+                # Message is not in sequence
+                continue
+
+            else:
+                # Message is > 1 and is received in-order
+                target_client_msg_nums[target_client_key] = index
+
+        bssids = set()
+        # Check if we have all 4 messages for the handshake between the same MACs
+        for (client_target, num) in target_client_msg_nums.iteritems():
+            if num == 4:
+                # We got a handshake!
+                bssid = client_target.split(',')[0]
+                bssids.add(bssid)
+
+        return [(bssid, None) for bssid in bssids]
+
+
+    def cowpatty_command(self):
+        return [
+            'cowpatty',
+            '-r', self.capfile,
+            '-s', self.essid,
+            '-c' # Check for handshake
+        ]
+
+    def cowpatty_handshakes(self):
+        ''' Returns True if cowpatty identifies a handshake, False otherwise '''
+        if not Process.exists('cowpatty'):
+            return []
+        if not self.essid:
+            return [] # We need a essid for cowpatty :(
+
+        proc = Process(self.cowpatty_command(), devnull=False)
+        for line in proc.stdout().split('\n'):
+            if 'Collected all necessary data to mount crack against WPA' in line:
+                return [(None, self.essid)]
+        return []
+
+
+    def pyrit_command(self):
+        return [
+            'pyrit',
+            '-r', self.capfile,
+            'analyze'
+        ]
+
+    def pyrit_handshakes(self):
+        ''' Returns True if pyrit identifies a handshake, False otherwise '''
+        if not Process.exists('pyrit'):
+            return []
+
+        bssid_essid_pairs = set()
+        hit_target = False
+        current_bssid = self.bssid
+        current_essid = self.essid
+        proc = Process(self.pyrit_command(), devnull=False)
+        for line in proc.stdout().split('\n'):
+            mac_regex = ('[a-zA-Z0-9]{2}:' * 6)[:-1]
+            match = re.search("^#\d+: AccessPoint (%s) \('(.*)'\):$"
+                % (mac_regex), line)
+            if match:
+                # We found a BSSID and ESSID
+                (bssid, essid) = match.groups()
+
+                # Compare to what we're searching for
+                if self.bssid and self.bssid.lower() == bssid.lower():
+                    current_essid = essid
+                    hit_target = True
+                    continue
+
+                elif self.essid and self.essid == essid:
+                    current_bssid = bssid
+                    hit_target = True
+                    continue
+
+                elif not self.bssid and not self.essid:
+                    # We don't know either
+                    current_bssid = bssid
+                    current_essid = essid
+                    hit_target = True
+                else:
+                    # This AccessPoint is not what we're looking for
+                    hit_Target = False
+            else:
+                # Line does not contain AccessPoint
+                if hit_target and ', good' in line:
+                    bssid_essid_pairs.add( (current_bssid, current_essid) )
+        return [x for x in bssid_essid_pairs]
+
+
+    def aircrack_command(self):
+        return 'echo "" | aircrack-ng -a 2 -w - -b %s "%s"' % (self.bssid, self.capfile)
+
+    def aircrack_handshakes(self):
+        if not self.bssid:
+            return []
+        (stdout, stderr) = Process.call(self.aircrack_command())
+        if 'passphrase not in dictionary' in stdout.lower():
+            return [(self.bssid, None)]
+        else:
+            return []
+
+    def analyze(self):
+        self.divine_bssid_and_essid()
+
+        pairs = self.tshark_handshakes()
+        Handshake.print_pairs(pairs, self.capfile, 'tshark')
+
+        pairs = self.pyrit_handshakes()
+        Handshake.print_pairs(pairs, self.capfile, 'pyrit')
+
+        pairs = self.cowpatty_handshakes()
+        Handshake.print_pairs(pairs, self.capfile, 'cowpatty')
+
+        pairs = self.aircrack_handshakes()
+        Handshake.print_pairs(pairs, self.capfile, 'aircrack')
+
+
+    def strip(self, outfile=None):
+        # XXX: This method might break aircrack-ng, use at own risk.
+        '''
+            Strips out packets from handshake that aren't necessary to crack.
+            Leaves only handshake packets and SSID broadcast (for discovery).
+            Args:
+                outfile - Filename to save stripped handshake to.
+                          If outfile==None, overwrite existing self.capfile.
+        '''
+        if not outfile:
+            outfile = self.capfile + '.temp'
+            replace_existing_file = True
+        else:
+            replace_existing_file = False
+
+        cmd = [
+            'tshark',
+            '-r', self.capfile, # input file
+            '-R', 'wlan.fc.type_subtype == 0x08 || wlan.fc.type_subtype == 0x05 || eapol', # filter
+            '-2', # tshark: -R without -2 is deprecated.
+            '-w', outfile # output file
+        ]
+        proc = Process(cmd)
+        proc.wait()
+        if replace_existing_file:
+            from shutil import copy
+            copy(outfile, self.capfile)
+            os.remove(outfile)
+            pass
+
+
+    @staticmethod
+    def print_pairs(pairs, capfile, tool=None):
+        '''
+            Prints out BSSID and/or ESSID given a list of tuples (bssid,essid)
+        '''
+        tool_str = ''
+        if tool:
+            tool_str = '{C}%s{W}: ' % tool.rjust(8)
+
+        if len(pairs) == 0:
+            Color.pl("{!} %s.cap file {R}does not{O} contain a valid handshake{W}"
+                % (tool_str))
+            return
+
+        for (bssid, essid) in pairs:
+            if bssid and essid:
+                Color.pl('{+} %s.cap file' % tool_str +
+                         ' {G}contains a valid handshake{W}' +
+                         ' for {G}%s{W} ({G}%s{W})' % (bssid, essid))
+            elif bssid:
+                Color.pl('{+} %s.cap file' % tool_str +
+                         ' {G}contains a valid handshake{W}' +
+                         ' for {G}%s{W}' % bssid)
+            elif essid:
+                Color.pl('{+} %s.cap file' % tool_str +
+                         ' {G}contains a valid handshake{W}' +
+                         ' for ({G}%s{W})' % essid)
+
+
+if __name__ == '__main__':
+    hs = Handshake('./tests/files/handshake_exists.cap', bssid='A4:2B:8C:16:6B:3A')
+
+    hs.analyze()
+    print "has_hanshake() =", hs.has_handshake()
+

wifite/model/interface.py

@@ -0,0 +1,102 @@
+#!/usr/bin/python2.7
+# -*- coding: utf-8 -*-
+
+from wifite.util.color import Color
+
+import re
+
+class Interface(object):
+    '''
+        Represents an 'interface' known by airmon-ng
+    '''
+
+    # Max length of fields.
+    # Used for printing a table of interfaces.
+    PHY_LEN = 6
+    NAME_LEN = 12
+    DRIVER_LEN = 20
+    CHIPSET_LEN = 30
+
+    def __init__(self, fields):
+        '''
+            Initializes & stores info about an interface.
+
+            Args:
+                Fields - list of fields
+                        0: PHY
+                        1: NAME
+                        2: DRIVER
+                        3: CHIPSET
+        '''
+        if len(fields) == 3:
+            phy = 'phyX'
+            match = re.search(' - \[(phy\d+)\]', fields[2])
+            if match:
+                phy = match.groups()[0]
+                fields[2] = fields[2][:fields[2].rfind(' - [')]
+            fields.insert(0, phy)
+        if len(fields) != 4:
+            raise Exception("Expected 4, got %d in %s" % (len(fields), fields))
+        self.phy = fields[0].strip()
+        self.name = fields[1].strip()
+        self.driver = fields[2].strip()
+        self.chipset = fields[3].strip()
+
+    def __str__(self):
+        ''' Colored string representation of interface '''
+        s = Color.s("{W}%s" % self.phy)
+        s += ' ' * max(Interface.PHY_LEN - len(self.phy), 0)
+
+        s += Color.s("{G}%s" % self.name)
+        s += ' ' * max(Interface.NAME_LEN - len(self.name), 0)
+
+        s += Color.s("{C}%s" % self.driver)
+        s += ' ' * max(Interface.DRIVER_LEN - len(self.driver), 0)
+
+        s += Color.s("{W}%s" % self.chipset)
+        s += ' ' * max(Interface.CHIPSET_LEN - len(self.chipset), 0)
+        return s
+
+    @staticmethod
+    def menu_header():
+        ''' Colored header row for interfaces '''
+        s = '    '
+        s += 'PHY'
+        s += ' ' * (Interface.PHY_LEN - len("PHY"))
+
+        s += 'Interface'
+        s += ' ' * (Interface.NAME_LEN - len("Interface"))
+        s += 'Driver'
+        s += ' ' * (Interface.DRIVER_LEN - len("Driver"))
+
+        s += 'Chipset'
+        s += ' ' * (Interface.CHIPSET_LEN - len("Chipset"))
+
+        s += '\n---'
+        s += '-' * (Interface.PHY_LEN + Interface.NAME_LEN + Interface.DRIVER_LEN + Interface.CHIPSET_LEN)
+        return s
+
+    @staticmethod
+    def get_mac(iface=None):
+        from Configuration import Configuration
+        from Process import Process
+        import re
+
+        if iface is None:
+            Configuration.initialize()
+            iface = Configuration.interface
+        if iface is None:
+            raise Exception('Interface must be defined (-i)')
+
+        output = Process(['ifconfig', iface]).stdout()
+        mac_regex = ('[a-zA-Z0-9]{2}-' * 6)[:-1]
+        match = re.search(' (%s)' % mac_regex, output)
+        if not match:
+            match = re.search('unspec (%s)' % mac_regex, output)
+            if not match:
+                raise Exception('Could not find the mac address for %s' % iface)
+        return match.groups()[0].replace('-', ':')
+
+if __name__ == '__main__':
+    mac = Interface.get_mac()
+    print 'wlan0mon mac address:', mac

wifite/model/result.py

@@ -0,0 +1,91 @@
+#!/usr/bin/python2.7
+# -*- coding: utf-8 -*-
+
+from ..util.color import Color
+
+import os
+import time
+from json import loads, dumps
+
+class CrackResult(object):
+    ''' Abstract class containing results from a crack session '''
+
+    # File to save cracks to, in PWD
+    cracked_file = "cracked.txt"
+
+    def __init__(self):
+        self.date = int(time.time())
+
+    def dump(self):
+        raise Exception("Unimplemented method: dump()")
+
+    def to_dict(self):
+        raise Exception("Unimplemented method: to_dict()")
+
+    def save(self):
+        ''' Adds this crack result to the cracked file and saves it. '''
+        name = CrackResult.cracked_file
+        json = []
+        if os.path.exists(name):
+            with open(name, 'r') as fid:
+                text = fid.read()
+            try:
+                json = loads(text)
+            except Exception, e:
+                Color.pl('{!} error while loading %s: %s' % (name, str(e)))
+        json.append(self.to_dict())
+        with open(name, 'w') as fid:
+            fid.write(dumps(json, indent=2))
+        Color.pl('{+} saved crack result to {C}%s{W} ({G}%d total{W})'
+            % (name, len(json)))
+
+    @classmethod
+    def load_all(cls):
+        if not os.path.exists(cls.cracked_file): return []
+        with open(cls.cracked_file, "r") as json_file:
+            json = loads(json_file.read())
+        return json
+
+    @staticmethod
+    def load(json):
+        ''' Returns an instance of the appropriate object given a json instance '''
+        if json['type'] == 'WPA':
+            from CrackResultWPA import CrackResultWPA
+            result = CrackResultWPA(json['bssid'],
+                                    json['essid'],
+                                    json['handshake_file'],
+                                    json['key'])
+        elif json['type'] == 'WEP':
+            from CrackResultWEP import CrackResultWEP
+            result = CrackResultWEP(json['bssid'],
+                                    json['essid'],
+                                    json['hex_key'],
+                                    json['ascii_key'])
+
+        elif json['type'] == 'WPS':
+            from CrackResultWPS import CrackResultWPS
+            result = CrackResultWPS(json['bssid'],
+                                    json['essid'],
+                                    json['pin'],
+                                    json['psk'])
+        result.date = json['date']
+        return result
+
+if __name__ == '__main__':
+    # Deserialize WPA object
+    Color.pl('\nCracked WPA:')
+    json = loads('{"bssid": "AA:BB:CC:DD:EE:FF", "essid": "Test Router", "key": "Key", "date": 1433402428, "handshake_file": "hs/capfile.cap", "type": "WPA"}')
+    obj = CrackResult.load(json)
+    obj.dump()
+
+    # Deserialize WEP object
+    Color.pl('\nCracked WEP:')
+    json = loads('{"bssid": "AA:BB:CC:DD:EE:FF", "hex_key": "00:01:02:03:04", "ascii_key": "abcde", "essid": "Test Router", "date": 1433402915, "type": "WEP"}')
+    obj = CrackResult.load(json)
+    obj.dump()
+
+    # Deserialize WPS object
+    Color.pl('\nCracked WPS:')
+    json = loads('{"psk": "the psk", "bssid": "AA:BB:CC:DD:EE:FF", "pin": "01234567", "essid": "Test Router", "date": 1433403278, "type": "WPS"}')
+    obj = CrackResult.load(json)
+    obj.dump()

wifite/model/target.py

@@ -0,0 +1,151 @@
+#!/usr/bin/python2.7
+# -*- coding: utf-8 -*-
+
+from wifite.util.color import Color
+
+import re
+
+class Target(object):
+    '''
+        Holds details for a "Target" aka Access Point (e.g. router).
+    '''
+
+    def __init__(self, fields):
+        '''
+            Initializes & stores target info based on fields.
+            Args:
+                Fields - List of strings
+                INDEX KEY             EXAMPLE
+                    0 BSSID           (00:1D:D5:9B:11:00)
+                    1 First time seen (2015-05-27 19:28:43)
+                    2 Last time seen  (2015-05-27 19:28:46)
+                    3 channel         (6)
+                    4 Speed           (54)
+                    5 Privacy         (WPA2)
+                    6 Cipher          (CCMP TKIP)
+                    7 Authentication  (PSK)
+                    8 Power           (-62)
+                    9 beacons         (2)
+                    10 # IV           (0)
+                    11 LAN IP         (0.  0.  0.  0)
+                    12 ID-length      (9)
+                    13 ESSID          (HOME-ABCD)
+                    14 Key            ()
+        '''
+        self.bssid      =     fields[0].strip()
+        self.channel    =     fields[3].strip()
+
+        self.encryption =     fields[5].strip()
+        if 'WPA' in self.encryption:
+            self.encryption = 'WPA'
+        elif 'WEP' in self.encryption:
+            self.encryption = 'WEP'
+        if len(self.encryption) > 4:
+            self.encryption = self.encryption[0:4].strip()
+
+        self.power      = int(fields[8].strip())
+        if self.power < 0:
+            self.power += 100
+
+        self.beacons    = int(fields[9].strip())
+        self.ivs        = int(fields[10].strip())
+
+        self.essid_known = True
+        self.essid_len   = int(fields[12].strip())
+        self.essid       =     fields[13].strip()
+        if self.essid == '\\x00' * self.essid_len or self.essid.strip() == '':
+            # Don't display "\x00..." for hidden ESSIDs
+            self.essid = None # '(%s)' % self.bssid
+            self.essid_known = False
+
+        self.wps = None
+
+        self.clients = []
+
+        self.validate()
+
+    def validate(self):
+        ''' Checks that the target is valid. '''
+        if self.channel == "-1":
+            raise Exception("Ignoring target with Negative-One (-1) channel")
+
+        # Filter broadcast/multicast BSSIDs, see https://github.com/derv82/wifite2/issues/32
+        bssid_broadcast = re.compile(r"^(ff:ff:ff:ff:ff:ff|00:00:00:00:00:00)$", re.IGNORECASE)
+        if bssid_broadcast.match(self.bssid):
+            raise Exception("Ignoring target with Broadcast BSSID (%s)" % self.bssid)
+
+        bssid_multicast = re.compile(r"^(01:00:5e|01:80:c2|33:33)", re.IGNORECASE)
+        if bssid_multicast.match(self.bssid):
+            raise Exception("Ignoring target with Multicast BSSID (%s)" % self.bssid)
+
+    def to_str(self, show_bssid=False):
+        '''
+            *Colored* string representation of this Target.
+            Specifically formatted for the "scanning" table view.
+        '''
+
+        max_essid_len = 25
+        essid = self.essid if self.essid_known else "(%s)" % self.bssid
+        # Trim ESSID (router name) if needed
+        if len(essid) > max_essid_len:
+            essid = essid[0:max_essid_len-3] + '...'
+        else:
+            essid = essid.rjust(max_essid_len)
+
+        if self.essid_known:
+            # Known ESSID
+            essid = Color.s("{C}%s" % essid)
+        else:
+            # Unknown ESSID
+            essid = Color.s("{O}%s" % essid)
+
+        if show_bssid:
+            bssid = Color.s('{O}%s  ' % self.bssid)
+        else:
+            bssid = ''
+
+        channel_color = "{G}"
+        if int(self.channel) > 14:
+            channel_color = "{C}"
+        channel = Color.s("%s%s" % (channel_color, str(self.channel).rjust(3)))
+
+        encryption = self.encryption.rjust(4)
+        if 'WEP' in encryption:
+            encryption = Color.s("{G}%s" % encryption)
+        elif 'WPA' in encryption:
+            encryption = Color.s("{O}%s" % encryption)
+
+        power = '%sdb' % str(self.power).rjust(3)
+        if self.power > 50:
+            color ='G'
+        elif self.power > 35:
+            color = 'O'
+        else:
+            color = 'R'
+        power = Color.s('{%s}%s' % (color, power))
+
+        wps = Color.s('{O} n/a')
+        if self.wps == True:
+            wps = Color.s('{G} yes')
+        elif self.wps == False:
+            wps = Color.s('{R}  no')
+        else:
+            wps = Color.s('{O} n/a')
+
+        clients = '       '
+        if len(self.clients) > 0:
+            clients = Color.s('{G}  ' + str(len(self.clients)))
+
+        result = '%s  %s%s  %s  %s  %s  %s' % (
+                essid, bssid, channel, encryption, power, wps, clients)
+        result += Color.s("{W}")
+        return result
+
+
+if __name__ == '__main__':
+    fields = 'AA:BB:CC:DD:EE:FF,2015-05-27 19:28:44,2015-05-27 19:28:46,1,54,WPA2,CCMP TKIP,PSK,-58,2,0,0.0.0.0,9,HOME-ABCD,'.split(',')
+    t = Target(fields)
+    t.clients.append("asdf")
+    t.clients.append("asdf")
+    print t.to_str()
+

wifite/model/wep_result.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python2.7
+# -*- coding: utf-8 -*-
+
+from ..util.color import Color
+from .result import CrackResult
+
+import time
+
+class CrackResultWEP(CrackResult):
+    def __init__(self, bssid, essid, hex_key, ascii_key):
+        self.result_type = 'WEP'
+        self.bssid     = bssid
+        self.essid     = essid
+        self.hex_key   = hex_key
+        self.ascii_key = ascii_key
+        super(CrackResultWEP, self).__init__()
+
+    def dump(self):
+        if self.essid:
+            Color.pl('{+}      ESSID: {C}%s{W}' % self.essid)
+        Color.pl('{+}      BSSID: {C}%s{W}' % self.bssid)
+        Color.pl('{+} Encryption: {C}%s{W}' % self.result_type)
+        Color.pl('{+}    Hex Key: {G}%s{W}' % self.hex_key)
+        if self.ascii_key:
+            Color.pl('{+}  Ascii Key: {G}%s{W}' % self.ascii_key)
+    
+    def to_dict(self):
+        return {
+            'type'      : self.result_type,
+            'date'      : self.date,
+            'essid'     : self.essid,
+            'bssid'     : self.bssid,
+            'hex_key'   : self.hex_key,
+            'ascii_key' : self.ascii_key
+        }
+
+if __name__ == '__main__':
+    crw = CrackResultWEP('AA:BB:CC:DD:EE:FF', 'Test Router', '00:01:02:03:04', 'abcde')
+    crw.dump()
+    crw.save()
+

wifite/model/wpa_result.py

@@ -0,0 +1,52 @@
+#!/usr/bin/python2.7
+# -*- coding: utf-8 -*-
+
+from ..util.color import Color
+from .result import CrackResult
+
+class CrackResultWPA(CrackResult):
+    def __init__(self, bssid, essid, handshake_file, key):
+        self.result_type = 'WPA'
+        self.bssid = bssid
+        self.essid = essid
+        self.handshake_file = handshake_file
+        self.key = key
+        super(CrackResultWPA, self).__init__()
+
+    def dump(self):
+        if self.essid:
+            Color.pl('{+} %s: {C}%s{W}' %
+                ('Access Point Name'.rjust(19), self.essid))
+        if self.bssid:
+            Color.pl('{+} %s: {C}%s{W}' %
+                ('Access Point BSSID'.rjust(19), self.bssid))
+        Color.pl('{+} %s: {C}%s{W}' %
+            ('Encryption'.rjust(19), self.result_type))
+        if self.handshake_file:
+            Color.pl('{+} %s: {C}%s{W}' %
+                ('Handshake File'.rjust(19), self.handshake_file))
+        if self.key:
+            Color.pl('{+} %s: {G}%s{W}' % ('PSK (password)'.rjust(19), self.key))
+        else:
+            Color.pl('{!} %s  {O}key unknown{W}' % ''.rjust(19))
+    
+    def to_dict(self):
+        return {
+            'type'  : self.result_type,
+            'date'  : self.date,
+            'essid' : self.essid,
+            'bssid' : self.bssid,
+            'key'   : self.key,
+            'handshake_file' : self.handshake_file
+        }
+
+if __name__ == '__main__':
+    w = CrackResultWPA('AA:BB:CC:DD:EE:FF', 'Test Router', 'hs/capfile.cap', 'abcd1234')
+    w.dump()
+
+    w = CrackResultWPA('AA:BB:CC:DD:EE:FF', 'Test Router', 'hs/capfile.cap', 'Key')
+    print '\n'
+    w.dump()
+    w.save()
+    print w.__dict__['bssid']
+

wifite/model/wps_result.py

@@ -0,0 +1,44 @@
+#!/usr/bin/python2.7
+# -*- coding: utf-8 -*-
+
+from ..util.color import Color
+from ..model.result import CrackResult
+
+import time
+
+class CrackResultWPS(CrackResult):
+    def __init__(self, bssid, essid, pin, psk):
+        self.result_type = 'WPS'
+        self.bssid = bssid
+        self.essid = essid
+        self.pin   = pin
+        self.psk   = psk
+        super(CrackResultWPS, self).__init__()
+
+    def dump(self):
+        if self.essid is not None:
+            Color.pl('{+} %s: {C}%s{W}' % (      'ESSID'.rjust(12), self.essid))
+        if self.psk is None:
+            psk = '{O}N/A{W}'
+        else:
+            psk = '{G}%s{W}' % self.psk
+        Color.pl('{+} %s: {C}%s{W}'     % (      'BSSID'.rjust(12), self.bssid))
+        Color.pl('{+} %s: {C}WPA{W} ({C}WPS{W})' % 'Encryption'.rjust(12))
+        Color.pl('{+} %s: {G}%s{W}'     % (     'WPS PIN'.rjust(12), self.pin))
+        Color.pl('{+} %s: {G}%s{W}'     % ('PSK/Password'.rjust(12), psk))
+
+    def to_dict(self):
+        return {
+            'type'  : self.result_type,
+            'date'  : self.date,
+            'essid' : self.essid,
+            'bssid' : self.bssid,
+            'pin'   : self.pin,
+            'psk'   : self.psk
+        }
+
+if __name__ == '__main__':
+    crw = CrackResultWPS('AA:BB:CC:DD:EE:FF', 'Test Router', '01234567', 'the psk')
+    crw.dump()
+    crw.save()
+