def _restore_deauthor_state(self):
card = NetworkCard(self.running_interface)
if card.get_mode() != self._previous_mode:
card.set_mode(self._previous_mode)
self._previous_mode = None
self.running_interface = None
def start_sniffer(self, interface):
"""
This method launches the necessary threads for the sniffing process.
"""
self.running_interface = interface
SessionManager().log_event(NeutralEvent("Starting AirScanner module."))
try:
card = NetworkCard(interface)
if card.get_mode().lower() != 'monitor':
card.set_mode('monitor')
except:
print "[-] Could not set card to monitor mode. Card might be busy."
SessionManager().log_event(
UnsuccessfulEvent(
"AirScanner start was aborted, unable to set card to monitor mode."
))
return
for plugin in self.plugins:
plugin.pre_scanning()
self.sniffer_running = True
self.sniffing_thread = Thread(target=self.sniff_packets)
self.sniffing_thread.start()
hopper_thread = Thread(target=self.hop_channels)
hopper_thread.start()
def start_sniffer(self, interface, hop_channels=True, fixed_channel=7):
self.running_interface = interface
try:
card = NetworkCard(interface)
if card.get_mode().lower() != 'monitor':
card.set_mode('monitor')
except:
print "[-] Could not set card to monitor mode. Card might be busy."
return
for plugin in self.plugins:
plugin.pre_scanning()
self.sniffer_running = True
self.sniffing_thread = Thread( target=self.sniff_packets)
self.sniffing_thread.start()
if hop_channels:
hopper_thread = Thread( target=self.hop_channels)
hopper_thread.start()
else:
try:
card = NetworkCard(interface)
card.set_channel(fixed_channel)
if card.get_channel() == fixed_channel:
print "[+] Set fixed channel to {}".format(fixed_channel)
else:
print "[-] Could not change channel, try unplugging your interface."
print "[/] Channel is on {}".format(card.get_channel())
except:
print "[-] Cannot set channel at the moment."
def _restore_injection_state(self):
try:
card = NetworkCard(self.injection_interface)
if card.get_mode().lower() != self._previous_mode:
card.set_mode(self._previous_mode)
self._previous_mode = None
except: pass
self.injection_interface = None
def _restore_injection_state(self):
try:
card = NetworkCard(self.running_interface)
if card.get_mode().lower() != self._previous_mode:
card.set_mode(self._previous_mode)
self._previous_mode = None
except:
pass
self.running_interface = None
def start_injection_attack(self, interface):
self.injection_interface = interface
card = NetworkCard(interface)
current_mode = card.get_mode().lower()
self._previous_mode = current_mode
if not (current_mode == 'monitor' or current_mode == 'ap'):
card.set_mode('monitor')
self.injection_running = True
injection_thread = Thread(target=self.injection_attack)
injection_thread.start()
def start_sniffer(self, interface):
self.running_interface = interface
card = NetworkCard(interface)
if card.get_mode() != 'monitor':
card.set_mode('monitor')
self.sniffing_thread = Thread( target=self.sniff_packets)
self.sniffer_running = True
self.sniffing_thread.start()
hopper_thread = Thread( target=self.hop_channels)
hopper_thread.start()
def sniff_packets(self):
card = NetworkCard(self.ap_interface)
if card.get_mode() != "monitor":
card.set_mode("monitor")
try:
sniff(iface=self.ap_interface, store=0, prn=self.handle_packet, stop_filter= (lambda pkt: self.should_stop))
except Exception as e:
print e
print "[-] Exception occurred while sniffing on interface '{}'".format(self.ap_interface)
self.should_stop = False
if card.get_mode() != "managed":
card.set_mode("managed")
def start_deauthentication_attack(self, interface):
# Restart services to avoid conflicts
self.running_interface = interface
card = NetworkCard(interface)
current_mode = card.get_mode()
self._previous_mode = current_mode
if current_mode != 'monitor':
card.set_mode('monitor')
self.deauth_running = True
deauth_thread = Thread(target=self.deauthentication_attack)
deauth_thread.start()
def sniff_packets(self):
card = NetworkCard(self.ap_interface)
if card.get_mode() != "monitor":
card.set_mode("monitor")
try:
sniff(iface=self.ap_interface,
store=0,
prn=self.handle_packet,
stop_filter=(lambda pkt: self.should_stop))
except Exception as e:
print e
print "[-] Exception occurred while sniffing on interface '{}'".format(
self.ap_interface)
self.should_stop = False
if card.get_mode() != "managed":
card.set_mode("managed")
def _clean_quit(self, wait = True):
self.sniffer_running = False
for plugin in self.plugins:
plugin.restore()
del self.plugins[:]
if wait:
self.sniffing_thread.join() # The sniffing_thread will stop once it receives the next packet
# Reset card operaing state to 'managed'
if self.running_interface != None:
card = NetworkCard(self.running_interface)
if card.get_mode() != 'managed':
card.set_mode('managed')
self.running_interface = None
def start_injection_attack(self, interface):
SessionManager().log_event(NeutralEvent("Starting AirInjector module."))
self.injection_interface = interface
card = NetworkCard(interface)
current_mode = card.get_mode().lower()
self._previous_mode = current_mode
if not (current_mode == 'monitor' or current_mode == 'ap'):
try:
card.set_mode('monitor')
except:
SessionManager().log_event(UnsuccessfulEvent("AirInjector start was aborted,"
" cannot set card to monitor mode."))
return
self.injection_running = True
injection_thread = Thread(target=self.injection_attack)
injection_thread.start()
def _clean_quit(self, wait = True):
self.sniffer_running = False
for plugin in self.plugins:
plugin.post_scanning()
plugin.restore()
del self.plugins[:]
if wait:
self.sniffing_thread.join() # The sniffing_thread will stop once it receives the next packet
# Reset card operaing state to 'managed'
if self.running_interface is not None:
try:
card = NetworkCard(self.running_interface)
if card.get_mode().lower() != 'managed':
card.set_mode('managed')
except: pass
self.running_interface = None
def start_sniffer(self, interface, hop_channels=True, fixed_channel=7):
self.running_interface = interface
card = NetworkCard(interface)
if card.get_mode() != 'monitor':
card.set_mode('monitor')
for plugin in self.plugins:
plugin.pre_scanning()
self.sniffer_running = True
self.sniffing_thread = Thread( target=self.sniff_packets)
self.sniffing_thread.start()
if hop_channels:
hopper_thread = Thread( target=self.hop_channels)
hopper_thread.start()
else:
card = NetworkCard(interface)
card.set_channel(fixed_channel)
def start_injection_attack(self, interface):
SessionManager().log_event(
NeutralEvent("Starting AirInjector module."))
self.injection_interface = interface
card = NetworkCard(interface)
current_mode = card.get_mode().lower()
self._previous_mode = current_mode
if not (current_mode == 'monitor' or current_mode == 'ap'):
try:
card.set_mode('monitor')
except:
SessionManager().log_event(
UnsuccessfulEvent("AirInjector start was aborted,"
" cannot set card to monitor mode."))
return
self.injection_running = True
injection_thread = Thread(target=self.injection_attack)
injection_thread.start()
def start_sniffer(self, interface):
"""
This method launches the necessary threads for the sniffing process.
"""
self.running_interface = interface
SessionManager().log_event(NeutralEvent("Starting AirScanner module."))
try:
card = NetworkCard(interface)
if card.get_mode().lower() != 'monitor':
card.set_mode('monitor')
except:
print "[-] Could not set card to monitor mode. Card might be busy."
SessionManager().log_event(UnsuccessfulEvent("AirScanner start was aborted, unable to set card to monitor mode."))
return
for plugin in self.plugins:
plugin.pre_scanning()
self.sniffer_running = True
self.sniffing_thread = Thread( target=self.sniff_packets)
self.sniffing_thread.start()
hopper_thread = Thread( target=self.hop_channels)
hopper_thread.start()
