bssid=None,

channel=None,

essid=None,

tx=None,

intent=None):

# all arguments are required

assert not any([

location is None,

bssid is None,

channel is None,

essid is None,

tx is None,

intent is None,

])

# return dict from arguments

_id = str(mmh3.hash(''.join([ bssid, str(channel), intent])))

return {

'id' : _id,

'location' : location,

'bssid' : bssid,

'channel' : channel,

'tx' : tx,

'essid' : essid,

'intent' : intent,

'timestamp' : time.time(),

wifi_connect(iface, essid)

last_hops = traceroute('google.com')

try:

while True:

time.sleep(5)

hops = traceroute('google.com')

if hops != last_hops:

alert = alert_factory(location=DEVICE_NAME,

bssid='not applicable',

channel=0,

intent='canary tripped!',

essid=essid)

shitlist.put(alert)

except KeyboardInterrupt:

while True:

print '[deauth worker] running deauth attack against', bssid

time.sleep(1)

#pckt = Dot11(addr1=client, addr2=bssid, addr3=bssid) / Dot11Deauth()

#while True:

# for i in range(64):

# if i == 0:

# print '[Sentrygun] Deauthing ', bssid

while True:

print '[deauth] running napalm attack against', bssid

time.sleep(1)

def on_napalm_target(self, *args):

alert = args[0]

napalm_list.put(alert)

if 'dismiss' in alert:

print '[punisher] ceasing any existing napalm attacks against', json.dumps(alert, indent=4, sort_keys=True)

else:

print '[punisher] initiating napalm attack against', json.dumps(alert, indent=4, sort_keys=True)

def on_deauth_target(self, *args):

alert = args[0]

deauth_list.put(alert)

if 'dismiss' in alert:

print '[punisher] ceasing any existing deauth attack against', json.dumps(alert, indent=4, sort_keys=True)

else:

try:

deauth_treatments = {}

while True:

alert = deauth_list.get()

_id = alert['id']

if 'dismiss' in alert:

if _id not in deauth_treatments:

continue

deauth_treatments[_id].terminate()

del deauth_treatments[_id]

elif _id in deauth_treatments:

continue

else:

bssid = alert['bssid']

print '[deauth_scheduler] received new target:', bssid

deauth_treatments[_id] = Process(target=deauth, args=(bssid,))

deauth_treatments[_id].daemon = True

deauth_treatments[_id].start()

except KeyboardInterrupt:

try:

napalm_treatments = {}

while True:

alert = napalm_list.get()

_id = alert['id']

if 'dismiss' in alert:

if _id not in napalm_treatments:

continue

napalm_treatments[_id].terminate()

del napalm_treatments[_id]

elif _id in napalm_treatments:

continue

else:

bssid = alert['bssid']

print '[napalm_scheduler] received new target:', bssid

napalm_treatments[_id] = Process(target=napalm, args=(bssid,))

napalm_treatments[_id].daemon = True

napalm_treatments[_id].start()

except KeyboardInterrupt:

socket = SocketIO(configs['server_addr'], configs['server_port'])

punisher_ns = socket.define(PunisherNamespace, '/punisher')

try:

socket.wait()

except KeyboardInterrupt:

server_uri = 'http://%s:%d/%s' %\

(configs['server_addr'], configs['server_port'], SERVER_ENDPOINT)

try:

while True:

alert = shitlist.get()

print '[alert] %s attack: notifying server at %s' %\

(alert['intent'], server_uri)

response = requests.post(server_uri, json=alert)

print '[alert] server at %s acknowledged notification with status code %d' % (server_uri, response.status_code)

except KeyboardInterrupt:

import sniffer

responding_aps = {}

try:

probe_responses = sniffer.response_sniffer(interface)

for response in probe_responses:

ssid = response['essid']

bssid = response['addr3'].lower()

channel = response['channel']

tx = response['tx']

print '[probe Response]', ssid, bssid, response['tx'], channel

if configs['evil_twin'] and ssid in whitelist:

if bssid not in whitelist[ssid]:

print '[anomaly] %s has ssid: %s but not in whitelist' % (bssid, ssid)

alert = alert_factory(location=DEVICE_NAME,

bssid=bssid,

channel=response['channel'],

intent='evil twin - whitelist',

tx=response['tx'],

essid=ssid)

shitlist.put(alert)

else:

ap = calibration_table['ssids'][ssid]['bssids'][bssid]

upper_bound = ap['upper_bound']

lower_bound = ap['lower_bound']

if tx > upper_bound or tx < lower_bound:

print '[anomaly] Illegal tx varation: %s ' % bssid

alert = alert_factory(location=DEVICE_NAME,

bssid=bssid,

channel=response['channel'],

intent='evil twin - tx',

tx=response['tx'],

essid=ssid)

shitlist.put(alert)

elif configs['karma']:

if bssid in responding_aps:

responding_aps[bssid].add(ssid)

else:

responding_aps[bssid] = set([])

responding_aps[bssid].add(ssid)

if len(responding_aps[bssid]) > 1:

print '[anomaly] %s has sent probe responses for %d SSIDs' % (bssid, len(responding_aps[bssid]))

alert = alert_factory(location=DEVICE_NAME,

bssid=bssid,

channel=response['channel'],

intent='karma',

tx=response['tx'],

essid=ssid)

shitlist.put(alert)

except KeyboardInterrupt:

import sniffer

while True:

# channel hop from main process

for channel in xrange(1, 14):

if configs['karma']:

for i in xrange(THRESHOLD):

next_essid = rand_essid()

sniffer.send_probe_requests(interface=interface, ssid=next_essid)

print '[channel hopper] Switching to channel', channel

os.system('iwconfig %s channel %d' % (configs['iface'], channel))

parser = ArgumentParser()

parser.add_argument('-i',

dest='iface',

required=True,

type=str,

help='Specify network interface to use')

parser.add_argument('-a',

dest='server_addr',

required=True,

type=str,

help='Send data to server at this address')

parser.add_argument('-p',

dest='server_port',

required=False,

default=80,

type=int,

help='Send data to server listening on this port')

parser.add_argument('--evil-twin',

dest='evil_twin',

action='store_true',

help='detect evil twin attacks')

parser.add_argument('--karma',

dest='karma',

action='store_true',

help='detect karma attacks')

parser.add_argument('--canary',

dest='canary',

type=str,

default='',

required=False,

help='Use canary to detect network drops (must specify essid and dedicated interface in the form essid:interface )')