def _add_command_args(self, commands):
commands.add_argument(
'--cracked',
action='store_true',
dest='cracked',
help=Color.s('Display previously-cracked access points'))
commands.add_argument('-cracked',
help=argparse.SUPPRESS,
action='store_true',
dest='cracked')
commands.add_argument(
'--check',
action='store',
metavar='file',
nargs='?',
const='<all>',
dest='check_handshake',
help=Color.
s('Check a .cap file (or all hs/*.cap files) for WPA handshakes'))
commands.add_argument('-check',
help=argparse.SUPPRESS,
action='store',
nargs='?',
const='<all>',
dest='check_handshake')
commands.add_argument(
'--crack',
action='store_true',
dest='crack_handshake',
help=Color.s('Show commands to crack a captured handshake'))
def dependency_check(self):
''' Check that required programs are installed '''
required_apps = [
'airmon-ng', 'iwconfig', 'ifconfig', 'aircrack-ng', 'aireplay-ng',
'airodump-ng', 'tshark'
]
optional_apps = [
'packetforge-ng', 'reaver', 'bully', 'cowpatty', 'pyrit', 'stdbuf',
'macchanger'
]
missing_required = False
missing_optional = False
for app in required_apps:
if not Process.exists(app):
missing_required = True
Color.pl('{!} {R}error: required app {O}%s{R} was not found' %
app)
for app in optional_apps:
if not Process.exists(app):
missing_optional = True
Color.pl(
'{!} {O}warning: recommended app {R}%s{O} was not found' %
app)
if missing_required:
Color.pl('{!} {R}required app(s) were not found, exiting.{W}')
sys.exit(-1)
if missing_optional:
Color.pl('{!} {O}recommended app(s) were not found')
Color.pl('{!} {O}wifite may not work as expected{W}')
def set_led(self, x, y, z, color):
ix, iy, iz = rounds(x, y, z)
if not is_in_cube(ix, iy, iz):
return
src_color = Color.object_to_color(color)
if src_color.a == 0.0:
return
new_color = None
if src_color.a != 1.0:
dest_color = self.led_cube[ix][iy][iz]
# alpha blend
newr = dest_color.r * (1.0 - src_color.a) + src_color.r * src_color.a
newg = dest_color.g * (1.0 - src_color.a) + src_color.g * src_color.a
newb = dest_color.b * (1.0 - src_color.a) + src_color.b * src_color.a
new_color = Color(newr, newg, newb)
else:
new_color = src_color
if new_color.is_black():
return
self.led_cube[ix][iy][iz] = new_color
led.SetLed(ix, iy, iz, int(new_color))
def __init__(self, device, name="no-name"):
"""
:param name:
:param device:
:type device: sphero.SpheroAPI
"""
super(TraceableSphero, self).__init__(name)
# FILTER USED FOR TRACKING
self.filter = FilterGlow()
# THE OBJECT FOR THE DEVICE
self.device = device
device.configure_locator(0, 0, 0, auto=False)
self.device.set_sensor_streaming_cb(self.on_sphero_data)
# DRAW TRACKED PATCH ATTRIBUTES
self.draw_tracked = False
self.draw_n_max_tracked_samples = 5
# VELOCITY ATTRIBUTES
self.draw_velocity = False
self.velocity_vector = Vector2D(0, 0)
self.velocity_color = Color((0, 255, 0))
self.max_velocity_len = 20
# IMU ATTRIBUTES
self.draw_imu = True
self.imu_vector = Vector2D(1.0, 1.0)
self.imu_yaw = None
self.imu_vector_len = 15
self.imu_color = Color((0, 0, 255))
def load_from_file(file_path, scene_speed, statistics_panel_width):
with open(file_path) as f:
line_number = 1
for line in f:
words = line.split()
# skip empty lines
if len(words) == 0:
line_number += 1
continue
# skip comments in file
if words[0][0] == '#':
line_number += 1
continue
if words[0] == 'Scene':
width = int(words[1])
height = int(words[2])
scene = Scene(width, height, scene_speed,
statistics_panel_width)
# elif words[0] == 'SensorDrivenRobot':
# x = float(words[1])
# y = float(words[2])
# robot = SensorDrivenRobot(x, y, ROBOT_SIZE, ROBOT_WHEEL_RADIUS)
# robot.label = line_number
# scene.put(robot)
elif words[0] == 'Box':
x = int(words[1])
y = int(words[2])
size = int(words[3])
box = Box(x, y, size, Color.random_bright())
box.label = line_number
scene.put(box)
elif words[0] == 'Wall':
x1 = int(words[1])
y1 = int(words[2])
x2 = int(words[3])
y2 = int(words[4])
point1 = Point(x1, y1)
point2 = Point(x2, y2)
wall = Wall(point1, point2, Color.random_bright())
wall.label = line_number
scene.put(wall)
elif words[0] == 'Light':
x = int(words[1])
y = int(words[2])
emitting_power = int(words[3])
light = Light(x, y, emitting_power, Color.YELLOW,
Color.BLACK)
light.label = line_number
scene.put(light)
line_number += 1
f.closed
return scene
def print_banner(self):
""" Displays ASCII art of the highest caliber. """
Color.pl('''\
{G} . {GR}{D} {W}{G} . {W}
{G}.´ · .{GR}{D} {W}{G}. · `. {G}wifite {D}%s{W}
{G}: : : {GR}{D} (¯) {W}{G} : : : {W}{D}automated wireless auditor
{G}`. · `{GR}{D} /¯\ {W}{G}´ · .´ {C}{D}https://github.com/derv82/wifite2
{G} ` {GR}{D}/¯¯¯\{W}{G} ´ {W}
''' % Configuration.version)
def check_handshake(self, capfile):
''' Analyzes .cap file for handshake '''
if capfile == '<all>':
Color.pl('{+} checking all handshakes in {G}"./hs"{W} directory\n')
try:
capfiles = [
os.path.join('hs', x) for x in os.listdir('hs')
if x.endswith('.cap')
]
except OSError, e:
capfiles = []
if len(capfiles) == 0:
Color.pl('{!} {R}no .cap files found in {O}"./hs"{W}\n')
def _draw_neighbors(self, agent_positions, agent_neighbors_indicies):
for i in range(len(agent_positions)):
agent_x = agent_positions[i][0]
agent_y = agent_positions[i][1]
color = Color(47, 72, 88)
if i in agent_neighbors_indicies:
color = Color(0, 255, 0)
elif i == 0:
color = Color(0, 0, 0)
draw.filled_circle(agent_x, agent_y, self._rad, color)
def __init__(self, pos: Vect2d, name: str, color: Color, creature_id: int) -> None:
"""Constructeur
Args:
pos (Vect2d): position de la créature
name (str): nom de la créature
color (Color): couleur de la créature
creature_id (int): id de la famille de la créature
"""
self.family = [self]
self.invincibility_family_time = time.time()
self.creature_id = creature_id
self.killer_id = None
self.pos = pos.copy()
self.speed = Vect2d(0, 0)
self.direction = Vect2d(0, 0)
self.split_speed = 0
self.inertia = 0
self.radius = self.BASE_RADIUS
self.color = color
self.opposite_color = Color.oppositeColor(color)
self.name = name
self.img = Skins.getRandomSkin()
self.score = Creature.BASE_SCORE
self.is_alive = True
def get_heatmap_color(self, value):
heatmap = [[47, 72, 88], [0, 109, 137], [0, 148, 163], [0, 187, 157],
[0, 223, 117], [0, 255, 0]]
idx1 = 0
idx2 = 0
fract_between = 0
if value <= 0:
idx1 = idx2 = 0
elif value >= 1:
idx1 = idx2 = len(heatmap) - 1
else:
value = value * (len(heatmap) - 1)
idx1 = floor(value)
idx2 = idx1 + 1
fract_between = value - float(idx1)
r = (heatmap[idx2][0] -
heatmap[idx1][0]) * fract_between + heatmap[idx1][0]
g = (heatmap[idx2][1] -
heatmap[idx1][1]) * fract_between + heatmap[idx1][1]
b = (heatmap[idx2][2] -
heatmap[idx1][2]) * fract_between + heatmap[idx1][2]
return Color(int(r), int(g), int(b))
def reset(cls) -> None:
"""Réinitialise la map"""
cls.start_time = time.time()
cls.game_finished = False
cls.player_infos = {}
cls.all_cells = []
cls.ref_time = -1 * cls.DELTA_T_NEW_CELL
cls.grid = [[[] for y in range(cls.grid_size.y)]
for x in range(cls.grid_size.x)]
cls.creatures = {}
cls.player_id = cls.generateId()
cls.focused_creature_id = cls.player_id
player = Player(Vect2d(cls.size.x / 2, cls.size.y / 2), "Player",
Color.randomColor(), cls.player_id)
cls.creatures[cls.player_id] = [player]
# Création du joueur
cls.bushes = []
for i in range(config.NB_BUSHES):
cls.createBush()
def create_boxes(self, number_to_add=1):
for i in range(number_to_add):
x = random.randint(0, self.scene.width)
y = random.randint(0, self.scene.height)
size = random.randint(self.BOX_SIZE_MIN, self.BOX_SIZE_INTERVAL)
box = self.build_box(x, y, size, Color.random_bright())
self.scene.put(box)
def dump():
''' (Colorful) string representation of the configuration '''
from util.color import Color
max_len = 20
for key in Configuration.__dict__.keys():
max_len = max(max_len, len(key))
result = Color.s('{W}%s Value{W}\n' %
'Configuration Key'.ljust(max_len))
result += Color.s('{W}%s------------------{W}\n' % ('-' * max_len))
for (key, val) in sorted(Configuration.__dict__.iteritems()):
if key.startswith('__') or type(
val) == staticmethod or val is None:
continue
result += Color.s("{G}%s {W} {C}%s{W}\n" %
(key.ljust(max_len), val))
return result
def draw(self, surface): self.grid.draw(surface) self.pieces.draw(surface) for piece in self.pieces: if piece.isSelected(): for cell in piece.getValidMoves(): cell.highlight(surface, Color.rainbow(), 2) self.getCellFromPos(piece.pos).highlight(surface, (0,255,0), 2)
def __init__(self, x, y, length, wheel_radius):
direction = random.uniform(-pi, pi)
super().__init__(x, y, length, Color.random_color(127, 127, 127),
Color.BLACK, direction)
self.length = length
self.wheel_radius = wheel_radius
self.speed_left_wheel = 0.0 # angular velocity of left wheel
self.speed_right_wheel = 0.0 # angular velocity of left wheel
self._delta = 0.01
self.deltax = None
self.deltay = None
def draw(self, surface):
self.grid.draw(surface)
self.pieces.draw(surface)
for piece in self.pieces:
if piece.isSelected():
for cell in piece.getValidMoves():
cell.highlight(surface, Color.rainbow(), 2)
self.getCellFromPos(piece.pos).highlight(
surface, (0, 255, 0), 2)
def run():
w = Wifite()
w.print_banner()
try:
w.main()
except Exception, e:
Color.pl('\n{!} {R}Error:{O} %s{W}' % str(e))
if Configuration.verbose > 0 or True:
Color.pl('\n{!} {O}Full stack trace below')
from traceback import format_exc
Color.p('\n{!} ')
err = format_exc().strip()
err = err.replace('\n', '\n{!} {C} ')
err = err.replace(' File', '{W}File')
err = err.replace(' Exception: ', '{R}Exception: {O}')
Color.pl(err)
Color.pl('\n{!} {R}Exiting{W}\n')
def __init__(self, w, h, title): #{
colorama.init()
os.system("mode {cols},{rows}".format(cols=w, rows=h))
os.system("title " + title)
#sys.stdout.write("\x1b]2;{name}\x07".format(name=title))
#sys.stdout.write("\x1b[8;{rows};{cols}t".format(rows=h, cols=w))
sys.stdout.write("\033[{col}m{char}\033[0m".format(col=Color.RGB(
252, 127, 0).getShort(),
char='YELLOW'))
sys.stdout.write("\033[31;1;5mCOLOR\033[0m")
sys.stdout.write("\033[44m\033[36mWORDS\033[0m\n")
def add_walls(self, number_to_add=1):
for i in range(number_to_add):
x1 = random.randint(0, self.scene.width)
y1 = random.randint(0, self.scene.height)
point1 = Point(x1, y1)
x2 = random.randint(0, self.scene.width)
y2 = random.randint(0, self.scene.height)
point2 = Point(x2, y2)
wall = self.build_wall(point1, point2,
Color.random_color(127, 127, 127))
self.scene.put(wall)
def main(self):
''' Either performs action based on arguments, or starts attack scanning '''
if os.getuid() != 0:
Color.pl('{!} {R}error: {O}wifite{R} must be run as {O}root{W}')
Color.pl('{!} {O}re-run as: sudo ./Wifite.py{W}')
Configuration.exit_gracefully(0)
self.dependency_check()
Configuration.initialize(load_interface=False)
if Configuration.show_cracked:
self.display_cracked()
elif Configuration.check_handshake:
self.check_handshake(Configuration.check_handshake)
elif Configuration.crack_handshake:
CrackHandshake()
else:
Configuration.get_interface()
self.run()
def user_wants_to_continue(self, targets_remaining, attacks_remaining=0):
''' Asks user if attacks should continue onto other targets '''
if attacks_remaining == 0 and targets_remaining == 0:
# No targets or attacksleft, drop out
return
prompt_list = []
if attacks_remaining > 0:
prompt_list.append(
Color.s('{C}%d{W} attack(s)' % attacks_remaining))
if targets_remaining > 0:
prompt_list.append(
Color.s('{C}%d{W} target(s)' % targets_remaining))
prompt = ' and '.join(prompt_list)
Color.pl('{+} %s remain, do you want to continue?' % prompt)
prompt = Color.s('{+} type {G}c{W} to {G}continue{W}' +
' or {R}s{W} to {R}stop{W}: ')
if raw_input(prompt).lower().startswith('s'):
return False
else:
return True
def __init__(self, pos: Vect2d) -> None:
"""
Constructeur
Args:
pos (Vect2d): position de la cellule
"""
self.color = Color.randomColor()
# On prend une couleur aléatoire
self.pos = pos
self.radius = self.BASE_RADIUS
self.score = 1
def __init__(self, settings, max_width, max_height, max_nth_initial_radius=3):
pos_coordinate = RandomCoordinate(max_width, max_height)
vector = RandomVector(settings)
color = Color.random_color() if settings.random_color else Color.PURPLE
width = randint(1, settings.max_bubble_line_width)
max_radius = randint(1, settings.max_bubble_radius)
max_generated_radius = max_radius // max_nth_initial_radius
if max_generated_radius < 1:
max_generated_radius = 1
if settings.max_bubble_line_width < max_generated_radius:
radius = randint(settings.max_bubble_line_width, max_generated_radius)
else:
radius = settings.max_bubble_line_width
super().__init__(pos_coordinate, vector, color, radius, width, max_radius)
def display_cracked(self):
''' Show cracked targets from cracked.txt '''
name = CrackResult.cracked_file
if not os.path.exists(name):
Color.pl('{!} {O}file {C}%s{O} not found{W}' % name)
return
with open(name, 'r') as fid:
cracked_targets = json.loads(fid.read())
if len(cracked_targets) == 0:
Color.pl('{!} {R}no results found in {O}%s{W}' % name)
else:
Color.pl('{+} displaying {G}%d {C}cracked target(s){W}\n' %
len(cracked_targets))
for item in cracked_targets:
cr = CrackResult.load(item)
cr.dump()
Color.pl('')
def createEnemy(cls) -> None:
"""Crée un nouvel ennemi en évitant le spawn-kill, apparition sur une
autre créature"""
ok = False
timed_out = False
compt = 0
while not ok and not timed_out:
ok = True
pos = Vect2d(
random.randrange(Creature.BASE_RADIUS * 2,
cls.size.x - Creature.BASE_RADIUS * 2),
random.randrange(Creature.BASE_RADIUS * 2,
cls.size.y - Creature.BASE_RADIUS * 2))
for k in cls.creatures.keys():
creatures_list = cls.creatures[k]
for creature in creatures_list:
if Vect2d.dist(pos, creature.pos) < (Creature.BASE_RADIUS +
creature.radius) * 2:
ok = False
if compt == 10:
timed_out = True
compt += 1
if not timed_out:
enemy_id = cls.generateId()
if cls.all_usernames is None:
size = random.randint(3, 5)
name = cls.generateNewName(size)
else:
name = cls.all_usernames[random.randrange(
len(cls.all_usernames))]
enemy = Enemy(pos, name, Color.randomColor(), enemy_id)
cls.creatures[enemy_id] = [enemy]
def buttonStart_Display(button: Button, mouse_pos: Vect2d) -> bool:
"""Affichage du bouton Start
Args:
button (Button): bouton start
mouse_pos (Vect2d): position de la souris
Returns:
hand_cursor (bool): si la souris doit être affichée comme une main ou un curseur
"""
if button.isMouseOver(mouse_pos):
# Arc-en-ciel
hand_cursor = True
button.color_sat = (button.color_sat - 3 + 100) % 100
else:
# Flash épileptique
hand_cursor = False
button.color_sat = 100
button.color_hue = (button.color_hue + 1) % 360
button_color = Color.HSVToRGB(button.color_hue, button.color_sat, 100)
min_size = max(button.size.x, button.size.y)
# Taille minimale entre la largeur et la hauteur
font_size = min_size * 50 / 400
Display.drawRect(button.pos, button.size, color=button_color, fill=True)
# Rectangle du bouton
Display.drawText(button.text,
button.pos + button.size / 2,
color=Color.BLACK,
size=font_size)
# Texte du bouton
return hand_cursor
def display(self) -> None:
"""Affichage du buisson"""
c = Color.linearGradient(Color.BUSH_COLOR_FULL,
Color.BUSH_COLOR_DEAD,
1-(self.health-1)/(Bush.BASE_HEALTH-1))
for i in range(self.health):
# Les pics du buisson
angle = i/self.health*2*math.pi + self.angle
offset = Vect2d(math.cos(angle), math.sin(angle))*Bush.RADIUS*(1+Bush.SHARPNESS/3)
Display.drawTriangle(pos=self.pos + offset,
color=c,
radius=Bush.RADIUS*Bush.SHARPNESS,
angle=2*math.pi/self.health*i + self.angle,
base_pos=Camera.pos)
# Le cercle du buisson
Display.drawCircle(pos=self.pos,
color=c,
radius=Bush.RADIUS,
base_pos=Camera.pos)
def draw_agents(self, agent_positions, agent_goal_velocities,
agent_velocities):
for i in range(len(agent_positions)):
# print(agent_positions[i])
agent_x = agent_positions[i][0]
agent_y = agent_positions[i][1]
v_i = agent_velocities[i]
norm_v_i = np.linalg.norm(v_i)
goal_v_i = agent_goal_velocities[i]
norm_goal_v_i = np.linalg.norm(goal_v_i)
normalized_v = norm_v_i / 2
draw.filled_circle(agent_x, agent_y, self._rad,
self.get_heatmap_color(normalized_v))
draw.line(agent_positions[i],
agent_positions[i] + 1.5 * self._rad * v_i / norm_v_i,
self.get_heatmap_color(normalized_v))
draw.line(
agent_positions[i],
agent_positions[i] + self._rad * goal_v_i / norm_goal_v_i,
Color(255, 255, 255))
def load_from_arguments():
''' Sets configuration values based on Argument.args object '''
from args import Arguments
args = Arguments(Configuration).args
if args.random_mac:
Configuration.random_mac = True
Color.pl(
'{+} {C}option:{W} using {G}random mac address{W} when scanning & attacking'
)
if args.channel:
Configuration.target_channel = args.channel
Color.pl(
'{+} {C}option:{W} scanning for targets on channel {G}%s{W}' %
args.channel)
if args.interface:
Configuration.interface = args.interface
Color.pl('{+} {C}option:{W} using wireless interface {G}%s{W}' %
args.interface)
if args.target_bssid:
Configuration.target_bssid = args.target_bssid
Color.pl('{+} {C}option:{W} targeting BSSID {G}%s{W}' %
args.target_bssid)
if args.five_ghz == True:
Configuration.five_ghz = True
Color.pl(
'{+} {C}option:{W} including {G}5Ghz networks{W} in scans')
if args.show_bssids == True:
Configuration.show_bssids = True
Color.pl(
'{+} {C}option:{W} showing {G}bssids{W} of targets during scan'
)
if args.no_deauth == True:
Configuration.no_deauth = True
Color.pl(
'{+} {C}option:{W} will {R}not{W} {O}deauth{W} clients during scans or captures'
)
if args.num_deauths and args.num_deauths > 0:
Configuration.num_deauths = args.num_deauths
Color.pl(
'{+} {C}option:{W} will send {G}%d{W} deauth packets when deauthing'
% Configuration.num_deauths)
if args.target_essid:
Configuration.target_essid = args.target_essid
Color.pl('{+} {C}option:{W} targeting ESSID {G}%s{W}' %
args.target_essid)
if args.ignore_essid is not None:
Configuration.ignore_essid = args.ignore_essid
Color.pl(
'{+} {C}option:{W} {O}ignoring ESSIDs that include {R}%s{W}' %
args.ignore_essid)
if args.scan_time:
Configuration.scan_time = args.scan_time
Color.pl(
'{+} {C}option:{W} ({G}pillage{W}) attack all targets after {G}%d{W}s'
% args.scan_time)
if args.verbose:
Configuration.verbose = args.verbose
Color.pl('{+} {C}option:{W} verbosity level {G}%d{W}' %
args.verbose)
if args.kill_conflicting_processes:
Configuration.kill_conflicting_processes = True
Color.pl(
'{+} {C}option:{W} kill conflicting processes {G}enabled{W}')
# WEP
if args.wep_filter:
Configuration.wep_filter = args.wep_filter
if args.wep_pps:
Configuration.wep_pps = args.wep_pps
Color.pl(
'{+} {C}option:{W} using {G}%d{W} packets-per-second on WEP attacks'
% args.wep_pps)
if args.wep_timeout:
Configuration.wep_timeout = args.wep_timeout
Color.pl(
'{+} {C}option:{W} WEP attack timeout set to {G}%d seconds{W}'
% args.wep_timeout)
if args.require_fakeauth:
Configuration.require_fakeauth = True
Color.pl(
'{+} {C}option:{W} fake-authentication is {G}required{W} for WEP attacks'
)
if args.wep_crack_at_ivs:
Configuration.wep_crack_at_ivs = args.wep_crack_at_ivs
Color.pl(
'{+} {C}option:{W} will start cracking WEP keys at {G}%d IVs{W}'
% args.wep_crack_at_ivs)
if args.wep_restart_stale_ivs:
Configuration.wep_restart_stale_ivs = args.wep_restart_stale_ivs
Color.pl(
'{+} {C}option:{W} will restart aireplay after {G}%d seconds{W} of no new IVs'
% args.wep_restart_stale_ivs)
if args.wep_restart_aircrack:
Configuration.wep_restart_aircrack = args.wep_restart_aircrack
Color.pl(
'{+} {C}option:{W} will restart aircrack every {G}%d seconds{W}'
% args.wep_restart_aircrack)
# WPA
if args.wpa_filter:
Configuration.wpa_filter = args.wpa_filter
if args.wordlist:
if os.path.exists(args.wordlist):
Configuration.wordlist = args.wordlist
Color.pl(
'{+} {C}option:{W} using wordlist {G}%s{W} to crack WPA handshakes'
% args.wordlist)
else:
Configuration.wordlist = None
Color.pl(
'{+} {C}option:{O} wordlist {R}%s{O} was not found, wifite will NOT attempt to crack handshakes'
% args.wordlist)
if args.wpa_deauth_timeout:
Configuration.wpa_deauth_timeout = args.wpa_deauth_timeout
Color.pl(
'{+} {C}option:{W} will deauth WPA clients every {G}%d seconds{W}'
% args.wpa_deauth_timeout)
if args.wpa_attack_timeout:
Configuration.wpa_attack_timeout = args.wpa_attack_timeout
Color.pl(
'{+} {C}option:{W} will stop WPA handshake capture after {G}%d seconds{W}'
% args.wpa_attack_timeout)
if args.ignore_old_handshakes:
Configuration.ignore_old_handshakes = True
Color.pl(
"{+} {C}option:{W} will {O}ignore{W} existing handshakes (force capture)"
)
if args.wpa_handshake_dir:
Configuration.wpa_handshake_dir = args.wpa_handshake_dir
Color.pl('{+} {C}option:{W} will store handshakes to {G}%s{W}' %
args.wpa_handshake_dir)
if args.wpa_strip_handshake:
Configuration.wpa_strip_handshake = True
Color.pl(
"{+} {C}option:{W} will {G}strip{W} non-handshake packets")
# WPS
if args.wps_filter:
Configuration.wps_filter = args.wps_filter
if args.wps_only:
Configuration.wps_only = True
Color.pl(
'{+} {C}option:{W} will *only* attack non-WEP networks with {G}WPS attacks{W} (no handshake capture)'
)
if args.no_wps:
Configuration.no_wps = args.no_wps
Color.pl(
'{+} {C}option:{W} will {O}never{W} use {C}WPS attacks{W} (Pixie-Dust/PIN) on targets'
)
if args.use_bully:
Configuration.use_bully = args.use_bully
Color.pl(
'{+} {C}option:{W} use {C}bully{W} instead of {C}reaver{W} for WPS Attacks'
)
if args.wps_pixie_timeout:
Configuration.wps_pixie_timeout = args.wps_pixie_timeout
Color.pl(
'{+} {C}option:{W} WPS pixie-dust attack will timeout after {G}%d seconds{W}'
% args.wps_pixie_timeout)
if args.wps_pixie_step_timeout:
Configuration.wps_pixie_step_timeout = args.wps_pixie_step_timeout
Color.pl(
'{+} {C}option:{W} Any step in the pixie-dust attack will timeout after {G}%d seconds{W}'
% args.wps_pixie_step_timeout)
if args.wps_fail_threshold:
Configuration.wps_fail_threshold = args.wps_fail_threshold
Color.pl(
'{+} {C}option:{W} will stop WPS attack after {G}%d failures{W}'
% args.wps_fail_threshold)
if args.wps_timeout_threshold:
Configuration.wps_timeout_threshold = args.wps_timeout_threshold
Color.pl(
'{+} {C}option:{W} will stop WPS attack after {G}%d timeouts{W}'
% args.wps_timeout_threshold)
if args.wps_skip_rate_limit == False:
Configuration.wps_skip_rate_limit = False
Color.pl(
'{+} {C}option:{W} will {G}continue{W} WPS attacks when rate-limited'
)
# Adjust encryption filter
Configuration.encryption_filter = []
if Configuration.wep_filter:
Configuration.encryption_filter.append('WEP')
if Configuration.wpa_filter:
Configuration.encryption_filter.append('WPA')
if Configuration.wps_filter:
Configuration.encryption_filter.append('WPS')
if len(Configuration.encryption_filter) == 3:
Color.pl(
'{+} {C}option:{W} targeting {G}all encrypted networks{W}')
elif len(Configuration.encryption_filter) == 0:
# Default to scan all types
Configuration.encryption_filter = ['WEP', 'WPA', 'WPS']
else:
Color.pl('{+} {C}option:{W} ' +
'targeting {G}%s-encrypted{W} networks' %
'/'.join(Configuration.encryption_filter))
# Adjust WEP attack list
Configuration.wep_attacks = []
import sys
seen = set()
for arg in sys.argv:
if arg in seen: continue
seen.add(arg)
if arg == '-arpreplay': Configuration.wep_attacks.append('replay')
if arg == '-fragment': Configuration.wep_attacks.append('fragment')
if arg == '-chopchop': Configuration.wep_attacks.append('chopchop')
if arg == '-caffelatte':
Configuration.wep_attacks.append('caffelatte')
if arg == '-p0841': Configuration.wep_attacks.append('p0841')
if arg == '-hirte': Configuration.wep_attacks.append('hirte')
if len(Configuration.wep_attacks) == 0:
# Use all attacks
Configuration.wep_attacks = [
'replay', 'fragment', 'chopchop', 'caffelatte', 'p0841',
'hirte'
]
elif len(Configuration.wep_attacks) > 0:
Color.pl('{+} {C}option:{W} using {G}%s{W} WEP attacks' %
'{W}, {G}'.join(Configuration.wep_attacks))
# Commands
if args.cracked: Configuration.show_cracked = True
if args.check_handshake:
Configuration.check_handshake = args.check_handshake
if args.crack_handshake: Configuration.crack_handshake = True
if capfile == '<all>':
Color.pl('{+} checking all handshakes in {G}"./hs"{W} directory\n')
try:
capfiles = [
os.path.join('hs', x) for x in os.listdir('hs')
if x.endswith('.cap')
]
except OSError, e:
capfiles = []
if len(capfiles) == 0:
Color.pl('{!} {R}no .cap files found in {O}"./hs"{W}\n')
else:
capfiles = [capfile]
for capfile in capfiles:
Color.pl('{+} checking for handshake in .cap file {C}%s{W}' %
capfile)
if not os.path.exists(capfile):
Color.pl('{!} {O}.cap file {C}%s{O} not found{W}' % capfile)
return
hs = Handshake(capfile,
bssid=Configuration.target_bssid,
essid=Configuration.target_essid)
hs.analyze()
Color.pl('')
def run(self):
'''
Main program.
1) Scans for targets, asks user to select targets
2) Attacks each target
'''
def run(self):
'''
Main program.
1) Scans for targets, asks user to select targets
2) Attacks each target
'''
s = Scanner()
if s.target:
# We found the target we want
targets = [s.target]
else:
targets = s.select_targets()
attacked_targets = 0
targets_remaining = len(targets)
for idx, t in enumerate(targets, start=1):
attacked_targets += 1
targets_remaining -= 1
Color.pl(
'\n{+} ({G}%d{W}/{G}%d{W})' % (idx, len(targets)) +
' starting attacks against {C}%s{W} ({C}%s{W})' %
(t.bssid, t.essid if t.essid_known else "{O}ESSID unknown"))
if 'WEP' in t.encryption:
attack = AttackWEP(t)
elif 'WPA' in t.encryption:
if t.wps:
attack = AttackWPS(t)
result = False
try:
result = attack.run()
except Exception as e:
Color.pl("\n{!} {R}Error: {O}%s" % str(e))
if Configuration.verbose > 0 or Configuration.print_stack_traces:
Color.pl('\n{!} {O}Full stack trace below')
from traceback import format_exc
Color.p('\n{!} ')
err = format_exc().strip()
err = err.replace('\n', '\n{!} {C} ')
err = err.replace(' File', '{W}File')
err = err.replace(' Exception: ',
'{R}Exception: {O}')
Color.pl(err)
except KeyboardInterrupt:
Color.pl('\n{!} {O}interrupted{W}\n')
if not self.user_wants_to_continue(
targets_remaining, 1):
break
if result and attack.success:
# We cracked it.
attack.crack_result.save()
continue
else:
# WPS failed, try WPA handshake.
attack = AttackWPA(t)
else:
# Not using WPS, try WPA handshake.
attack = AttackWPA(t)
else:
Color.pl(
"{!} {R}Error: {O}unable to attack: encryption not WEP or WPA"
)
continue
try:
attack.run()
except Exception, e:
Color.pl("\n{!} {R}Error: {O}%s" % str(e))
if Configuration.verbose > 0 or True:
Color.pl('\n{!} {O}Full stack trace below')
from traceback import format_exc
Color.p('\n{!} ')
err = format_exc().strip()
err = err.replace('\n', '\n{!} {C} ')
err = err.replace(' File', '{W}File')
err = err.replace(' Exception: ', '{R}Exception: {O}')
Color.pl(err)
except KeyboardInterrupt:
Color.pl('\n{!} {O}interrupted{W}\n')
if not self.user_wants_to_continue(targets_remaining):
break
