[wifihood] / wifisniffer / wifilogger.py

#!/usr/bin/python

import pcapy
import struct

iface = 'wlan0'

import time

from ieee80211 import *

max_time = 15 * 60
tstamp = time.time()

logfile = open( "wifilogger.log" , "a" )

max_bytes = 1024
promiscuous = False
read_timeout = 100 # in milliseconds
pc = pcapy.open_live(iface, max_bytes, promiscuous, read_timeout)


channel_hop = [ 30.0 , False ]

def channel_change ( ) :
    try :
        wlan["channel"] = ( wlan["channel"] ) % 12 + 1
    except pyiw.error, error:
        print "PYIW error : %s" % error
    else :
        if channel_hop[0] :
            channel_hop[1] = threading.Timer( channel_hop[0] , channel_change ) 
            channel_hop[1].start()


def parse_radiotap( radiotap , it_present ) :

    fields = []
    rfmt , padstr = "<" , ""
    for name,bit,fmt,pad in ratiotap_header_bits :
        if it_present & ( 0x1 << bit ) :
            if not fmt :
                print "ERROR : unknown bit %s (%d) set" % ( name , bit )
                return
            fields.append( name )
            if fmt == "hh" :
                fields.append( "CHANNEL_BITMAP" )
            rfmt += fmt
            if pad :
                padstr += "x"
    values = struct.unpack(rfmt+padstr,radiotap)

    radio_hdr = {}
    for i in range(len(fields)) :
        radio_hdr[fields[i]] = values[i]

    flags = []
    for name,value in radiotap_flags :
        if radio_hdr['FLAGS'] & value == value :
            flags.append( name )
    if radio_hdr['FLAGS'] != 16 and radio_hdr['FLAGS'] != 18 :
        # 16 - FCS
        # 18 - SHORTPRE , FCS
        print 'WARNING : Unexpected flags : (%s) %s' % ( radio_hdr['FLAGS'] , " , ".join( flags ) )
    radio_hdr['_flags'] = flags

    channel = []
    for name,value in channel_flags :
        if radio_hdr['CHANNEL_BITMAP'] & value == value :
            channel.append( name )
    if radio_hdr['CHANNEL_BITMAP'] != 160 and radio_hdr['CHANNEL_BITMAP'] != 192 :
        # 160 - CCK , 2GHZ
        # 192 - OFDM , 2GHZ
        print 'WARNING : Unexpected channel flags : (%s) %s' % ( radio_hdr['CHANNEL_BITMAP'] , " , ".join( channel ) )
    radio_hdr['_channel_bitmap'] = channel

    return radio_hdr


class CaptureEnd ( Exception ) : pass


def dealWithPacket ( hdr , data ) :

    if hdr.getlen() != hdr.getcaplen() :
        print "ERROR : bad sizes in header : %d vs. %d" % ( hdr.getlen() , hdr.getcaplen() )
        return
    if len(data) != hdr.getlen() :
        print "ERROR : Data lenght does not match"
        return

    it_version , it_len , it_present = struct.unpack("<Bxhl",data[:8])
    if it_version != 0 :
        print "ERROR : Bad version (%s), it is probably not radiotap header" % it_version
        return
    if it_len <= 0 :
        print "ERROR : Bad length on radiotap header"
        return
    if it_len != 32 :
        print "ERROR : Strange length on radiotap header"
        return

    radio_hdr = parse_radiotap( data[8:it_len] , it_present )
    if not radio_hdr :
        return


    payload = data[it_len:]

    pcktlen = len(payload)

    frame_ctl , frame_ctl2 , duration_id = struct.unpack("BBh",payload[:4])
    pointer  = 4
    pcktlen -= 4


    for name,value in frame_types :
        if frame_ctl & 0x0c == value :
            frame_type = name
            break
    else :
        print "ERROR : unknown frame type %s" % ( frame_ctl & 0x0c , )
        return

    if frame_type == "MGT" :
        for name,value in management_subtypes :
            if frame_ctl & 0xf0 == value :
                frame_subtype = name
                break
        else :
            print "ERROR : unknown MGT subtype %s" % ( frame_ctl & 0xf0 , )
            return

    elif frame_type == "CTL" :
        for name,value in control_subtypes :
            if frame_ctl & 0xf0 == value :
                frame_subtype = name
                break
        else :
            print "ERROR : unknown CTL subtype %s" % ( frame_ctl & 0xf0 , )
            return

    elif frame_type == "DATA" :
        _subtype = []
        for name,value in data_subtypes :
            if frame_ctl & 0xf0 == value :
                _subtype.append( name )
        frame_subtype = "-".join( _subtype )

    else :
        print "Handling of frame type %s not implemented" % frame_type
        return


    for name,value in directions : # Only for DATA frames ???
        if frame_ctl2 & 0x03 == value :
            direction = name
            break
    else :
        print "ERROR : unknown direction %s" % ( frame_ctl2 & 0x03 , )
        return


    mac_str = "BBBBBB" # is leading '<' required
    mac_fmt = "%02X:%02X:%02X:%02X:%02X:%02X"

    maclist = []
    for i in range(3) :
        maclist.append( mac_fmt % struct.unpack( mac_str , payload[pointer:pointer+6] ) )
        pointer += 6
        pcktlen -= 6
        if pcktlen < 6 :
            break


    if frame_type != "CTL" :
        sequence = struct.unpack("BB",payload[pointer:pointer+2])
        pointer += 2
        pcktlen -= 2
    else :
        sequence = ( -1 , -1 )


    if frame_type == "DATA" :
        maclist.append( mac_fmt % struct.unpack( mac_str , payload[pointer:pointer+6] ) )
        pointer += 6
        pcktlen -= 6


    logfile.write( "%4s %13s %6s %4d [ %2d %2d ] read %4d missing %4d" % (frame_type,frame_subtype,direction,radio_hdr['CHANNEL'],radio_hdr['FLAGS'],radio_hdr['CHANNEL_BITMAP'],pointer,pcktlen) )
    logfile.write( " = %s %s " % ( radio_hdr['DBM_ANTSIGNAL'] , radio_hdr['DBM_ANTNOISE'] ) )
    logfile.write( " ; %4d %4d " % sequence )
    logfile.write( " - %4d :" % duration_id )
    logfile.write( " %s"*len(maclist) % tuple(maclist) )
    logfile.write( "\n" )

    curtime = time.time()
    if curtime - tstamp > max_time :
        channel_hop[0] = 0
        raise CaptureEnd( "Neighborhoud scan completed" )


if channel_hop[0]  :
    channel_hop[1] = threading.Timer( channel_hop[0] , channel_change ) 
    channel_hop[1].start()


packet_limit = -1 # infinite
try :
    pc.loop( packet_limit , dealWithPacket )
except CaptureEnd , ex :
    print "FINISED : %s" % ex
except Exception , ex :
    print "ERROR : %s" % ex

logfile.close()