def __init__(self, config={}):
"""
Sets up main file.
:TODO:
- Make parameter_file default value configurable, or shorter.
- Extra-capabilities stuff is still confusing
"""
self.config = config
self._target = Target()
self._mon_iface = None
self.target_dir = tempfile.mkdtemp()
self.resources_dir = os.path.join(os.path.dirname(unicode(__file__, sys.getfilesystemencoding())), "resources")
if 'parameter_file' not in self.config:
self.config['parameter_file'] = os.path.join(self.resources_dir,
"parameters.json")
self.parameters = json.load(open(self.config['parameter_file']))
self.aircrack = AircrackSession(self.parameters)
self.extra_capabilities = dict([(extra, getattr(getattr(capabilities, extra), 'main')(self)) for extra in capabilities.__all__])
self.reaver_targets = []
for cap_name in capabilities.__all__:
# This is so we can have external capabilities to manage attacks in hackability stuff.
# Right now, to use reaver =P
setattr(self, cap_name, lambda x, _name=cap_name:
self.extra_capabilities[_name].hack(x))
class AiroscriptSession(Airoscript):
"""
Basic airoscriptng session object.
This is the basic airoscriptng object.
Handles network interfaces.
Main interaction with outer world will be here.
"""
def __init__(self, config={}):
"""
Sets up main file.
:TODO:
- Make parameter_file default value configurable, or shorter.
- Extra-capabilities stuff is still confusing
"""
self.config = config
self._target = Target()
self._mon_iface = None
self.target_dir = tempfile.mkdtemp()
self.resources_dir = os.path.join(os.path.dirname(unicode(__file__, sys.getfilesystemencoding())), "resources")
if 'parameter_file' not in self.config:
self.config['parameter_file'] = os.path.join(self.resources_dir,
"parameters.json")
self.parameters = json.load(open(self.config['parameter_file']))
self.aircrack = AircrackSession(self.parameters)
self.extra_capabilities = dict([(extra, getattr(getattr(capabilities, extra), 'main')(self)) for extra in capabilities.__all__])
self.reaver_targets = []
for cap_name in capabilities.__all__:
# This is so we can have external capabilities to manage attacks in hackability stuff.
# Right now, to use reaver =P
setattr(self, cap_name, lambda x, _name=cap_name:
self.extra_capabilities[_name].hack(x))
def list_wifi(self):
"""
Returns a list of all the available wireless networks
"""
# If the driver is not using the new stack, screw them.
return [iface for iface in netifaces.interfaces() if "wlan" in iface]
def setup_wifi(self, iface):
"""
Starts monitor mode interface and checks it's ok.
:TODO:
- Injection test.
"""
self.config['wifi'] = iface
os.environ['MON_PREFIX'] = self.config["name"]
self.should_be_mon_iface = self.config["name"] + "0"
ifaddr = netifaces.ifaddresses(self.config['wifi'])
self.mac_addr = ifaddr[netifaces.AF_LINK][0]['addr']
if self.should_be_mon_iface not in netifaces.interfaces():
self.aircrack.airmon(OrderedDict([('command', "start"),
('wireless', self.config["wifi"])]), self.set_mon_iface)
else:
self._mon_iface = self.should_be_mon_iface
return self._mon_iface
def get_mac_addr(self):
"""
Return mac address of the interface
"""
return self.mac_addr
@property
def mon_iface(self):
"""
Return current monitor interface name
"""
return self._mon_iface
@mon_iface.setter
def mon_iface(self, mon_iface):
"""
Sets monitor interface (setter)
"""
self._mon_iface = mon_iface
def set_mon_iface(self, result):
"""
Sets monitor interface.
Checks that final monitor interface is really what it should be.
"""
mon_result = result.communicate()
for line in mon_result[0].splitlines():
mon_regex = '(.*)\((.*)monitor mode enabled on (.*)\)(.*)'
monitor_test = re.match(mon_regex, line)
if monitor_test:
self._mon_iface = monitor_test.group(3)
if not self.mon_iface == self.should_be_mon_iface:
debug("Monitor interface is {} and should be {}".format(
self.mon_iface, self.should_be_mon_iface))
return True
def del_mon_iface(self):
"""
Deletes own monitor interface from system (cleanup)
"""
return self.aircrack.launch("iw", [self.mon_iface, "del"])
@property
def target(self):
"""
Returns currently selected target (getter)
"""
return self.get_target
def get_target(self):
"""
Returns currently selected target, clean to send it via xmlrpc
"""
return clean_to_xmlrpc(self._target, ['properties', 'parent'])
@target.setter
def target(self, target):
"""
target setter
"""
return self.set_target(target)
def set_target(self, target):
"""
This way we only have to do something like
self.target = current_targets[10] and it'll automatically
make an object from it.
"""
if not isinstance(target, Target):
if isinstance(target, list):
target = dict(target)
self._target = Target(self)
self._target.from_dict(target)
else:
self._target = target
@property
def current_targets(self):
"""
Returns current targets (getter)
"""
return self.get_current_targets()
def get_current_targets(self):
"""
Parses airodump-ng's output file, creating a Target object
for each AP found, with its currently detected clients.
"""
aps = []
clients = []
scan_file = "{}/{}-01.csv".format(self.target_dir, self.config["name"])
with open(scan_file) as f:
dictcsv = [a for a in csv.DictReader(f, skipinitialspace=True)]
if "reaver" in self.extra_capabilities:
self.reaver_targets = self.extra_capabilities['reaver'].scan(
scan_file)
currently_processing_aps = True
for element in dictcsv:
element = element[None]
if currently_processing_aps:
if element[0] == "Station MAC":
currently_processing_aps = False
clients.append(element)
else:
aps.append(element)
else:
clients.append(element)
if len(aps) == 0:
return False
ap_headers = aps.pop(0)
client_headers = [a.lstrip(" ") for a in clients.pop(0)]
clients = [dict(zip(client_headers, client)) for client in clients]
a = [Target(self).from_dict(dict(zip(ap_headers, ap)), clients) for ap in aps]
return sorted(a, key=lambda x: x['hackability']['value'], reverse=True)
def listMethods(self):
"""
Hack to return public methods of this object via XMLRPC
:TODO:
- Make this work
"""
return list_public_methods(self)
def _methodHelp(self, method):
"""
Hack to return public methods' help of this object via XMLRPC
:TODO:
- Make this work
"""
f = getattr(self, method)
return inspect.getdoc(f)
