def main():
lst=[]
i=0
while True:
#print(len(cap))
header, payload= cap.next()
dest_mac, src_mac, eth_proto, data= ethrnet_frame(payload)
#print('\nEthernet Frame:')
a=('Desitantion: {}, Source:{}, Protocol:{}'.format(dest_mac,src_mac,eth_proto))
p1 = manuf.MacParser(update=True)
if src_mac== 'F6:5C:89:8C:45:64':
src_val= 'Local'
else:
src_val=p1.get_manuf(src_mac)
p2 = manuf.MacParser(update=True)
if dest_mac== 'F6:5C:89:8C:45:64':
dst_val= 'Local'
else:
dst_val=p2.get_manuf(dest_mac)
#print(src_val)
#print(dst_val)
i=i+1
if (i==7):
print('ALERT!!!!')
#if src_val==None or dst_val== None:
# print(a)
else:
print('.')
lst.append(a)
def getOUIDB():
ouidb = None
if hasOUILookup:
if os.path.isfile('manuf'):
# We have the file but let's not update it every time we run the app.
# every 90 days should be plenty
last_modified_date = datetime.datetime.fromtimestamp(os.path.getmtime('manuf'))
now = datetime.datetime.now()
age = now - last_modified_date
if age.days > 90:
updateflag = True
else:
updateflag = False
else:
# We don't have the file, let's get it
updateflag = True
try:
ouidb = manuf.MacParser(update=updateflag)
except:
if updateflag:
print("WARNING: Unable to update mac address vendor database. Continuing with old database.")
try:
ouidb = manuf.MacParser(update=False)
except:
print("WARNING: Unable to open the mac address vendor database. Disabling lookup.")
ouidb = None
else:
ouidb = None
return ouidb
def get_interface_manufacturer(mac):
try:
p = manuf.MacParser()
except FileNotFoundError:
p = manuf.MacParser(update=True)
return p.get_manuf(mac)
def show_vendors():
other = 0.032 # percentage threshold of being put under 'Others'
sizes = {}
vendors = {}
total = 0
data = csv.reader(open(file_path), delimiter=' ')
for row in data:
MAC_scr = row[1][0:8]
if MAC_scr in sizes:
sizes[MAC_scr] += 1
else:
sizes[MAC_scr] = 1
total += 1
p = manuf.MacParser(update=True)
for key, value in sizes.items():
vendor = p.get_manuf(key + ':00:00:00')
if vendor in vendors:
vendors[vendor] += value
else:
vendors[vendor] = value
vendors2 = {"other": 0}
for key, value in vendors.items():
if value < total * other:
vendors2["other"] += value
else:
vendors2[key] = value
plt.pie(vendors2.values(), labels=vendors2.keys(), autopct='%1.1f%%', shadow=True, startangle=140)
plt.show()
def macaddressconverterprobe():
for i in range(50):
p = manuf.MacParser(update=True)
mycursor.execute(
"""SELECT wlansa from dwccincomingprobe WHERE wlansaconverted IS NULL OR wlansaconverted = '' limit 1;"""
)
mactochange = mycursor.fetchone()
print "The probe mac that will be changed", mactochange
if mactochange is None:
print "all probe MAC matched to vendors"
return
else:
#This below will remove the punctuation for the VAR
mactochange = ''.join(c for c in mactochange
if c not in string.punctuation)
changedmac = p.get_manuf(mactochange)
changedmacstr = str(changedmac)
mactochangestr = str(mactochange)
#This below will write the mac vendor back to the database
mycursor.execute(
"UPDATE dwccincomingprobe SET wlansaconverted = " +
` changedmacstr ` + " WHERE wlansa = " + ` mactochangestr ` +
" ;")
# macaddressconverterap()
print "finished a round up to 50 probe mac"
def create_webapp(database_loc, log_file="-", verbose=False):
setup_logging(log_file, verbose)
parser = manuf.MacParser(update=True)
bottle.TEMPLATE_PATH.append(VIEWS_DIR)
def pretty_print_mac_info(mac):
info = parser.get_all(mac)
if info.manuf is None:
return "Vendor: ???"
elif info.comment is None:
return "Vendor: {0}".format(info.manuf)
else:
return "Vendor: {0} ({1})".format(info.manuf, info.comment)
app = bottle.Bottle()
db_conn = create_connection(database_loc)
write_schema(db_conn)
views = NodeViews(app,
db_conn,
mac_decoder=pretty_print_mac_info,
webserver_data_generator=webserver_info_hof())
views.attach()
api = NodeAPI(app, db_conn)
api.attach()
return app
def create_device_list(self):
device_list_unfiltered = []
print("Please wait while we generate the device list.")
mac_parser = manuf.MacParser(update=True)
for pkt in self.cap:
for device in device_list_unfiltered:
if device.MAC == pkt.eth.src:
try:
if device.IP == "" and pkt.ip.src != "0.0.0.0" and ipaddress.ip_address(
pkt.ip.src).is_private:
device.IP = pkt.ip.src
except AttributeError:
pass
break
else:
manufacturer = str(mac_parser.get_manuf(pkt.eth.src))
if manufacturer != "None":
new_device = Device()
new_device.MAC = pkt.eth.src
new_device.Manufacturer = manufacturer
try:
if pkt.ip.src != "0.0.0.0" and ipaddress.ip_address(
pkt.ip.src).is_private:
new_device.IP = pkt.ip.src
else:
raise AttributeError
except AttributeError:
new_device.IP = ""
device_list_unfiltered.append(new_device)
for device in device_list_unfiltered:
if device.MAC == pkt.eth.dst:
try:
if device.IP == "" and pkt.ip.dst != "0.0.0.0" and ipaddress.ip_address(
pkt.ip.dst).is_private:
device.IP = pkt.ip.dst
except AttributeError:
pass
break
else:
manufacturer = str(mac_parser.get_manuf(pkt.eth.dst))
if manufacturer != "None":
new_device = Device()
new_device.MAC = pkt.eth.dst
new_device.Manufacturer = manufacturer
try:
if pkt.ip.dst != "0.0.0.0" and ipaddress.ip_address(
pkt.ip.dst).is_private:
new_device.IP = pkt.ip.dst
else:
raise AttributeError
except AttributeError:
new_device.IP = ""
device_list_unfiltered.append(new_device)
for device in device_list_unfiltered:
if device.IP != "":
self.__device_list.append(device)
def get_client_details(mac_address, arp_table=None):
arp_table = arp_table if arp_table is not None else get_arp_table()
client_details = {
'mac_address': mac_address,
'ip_address': arp_table[mac_address],
'manufacturer': manuf.MacParser().get_manuf(mac_address),
}
return client_details
def mac_to_vendor(mac):
"""
Args:
mac ():
Returns:
"""
p = manuf.MacParser(update=False)
return p.get_manuf_long(mac)
def __init__(self, MAC, latitude,
longitude): #Creates a new device instance
self.manuf = manuf.MacParser()
self.MAC = MAC
self.firstSeen = datetime.datetime.utcnow()
self.lastSeen = self.firstSeen
self.seenCount = 1
self.ESSIDs = set()
self.manufacturer = self.manuf.get_manuf_long(MAC)
self.latitude = latitude
self.longitude = longitude
def proc(p):
if ( p.haslayer(Dot11ProbeReq) ):
mac=re.sub('','',p.addr2)
ssid=p[Dot11Elt].info
ssid=ssid.decode('utf-8','ignore')
v = manuf.MacParser(update=True)
ven = v.get_manuf(p.addr2)
if ssid == "":
ssid="gen-probe no SSID"
print >> f, strftime("%m/%d/%Y %H:%M:%S - ") + "[%s] - [%s] looking for --> [%s]" %(mac,ven,ssid)
print strftime("%m/%d/%Y %H:%M:%S - ") + "[%s] - [%s] looking for --> [%s]" %(mac,ven,ssid)
def find(time_range, hostname_must_contains=[], vendors=[]):
events = msiempy.event.EventManager(
fields=["HostID", "UserIDSrc", "SrcIP", "SrcMac", "DSIDSigID"],
time_range=time_range,
filters=[
msiempy.event.FieldFilter("Alert.DSIDSigID",
[DHCP_RENEW, RADIUS_START])
],
limit=500,
)
print("Loading data...")
events.load_data(slots=10, workers=5, max_query_depth=2)
print("{} events have been loaded from the SIEM".format(len(events)))
if len(vendors) > 0:
print("Filtering vendors...")
mac = manuf.MacParser(update=True)
vendor_filtered_events = list()
for event in events:
device_vendor = mac.get_manuf(event["Alert.SrcMac"])
if device_vendor == None:
continue
for vendor in vendors:
if vendor.lower() in device_vendor.lower():
vendor_filtered_events.append(event)
break
events = vendor_filtered_events
print("{} events matches the vendor(s)".format(len(events)))
print("Aggregating events and devices...")
devices = aggregate_list_based_on_SrcMac(events)
print("{} unique devices in total".format(len(devices)))
# Apply host filters
host_filtered_devices = list()
for dev in devices:
if len(hostname_must_contains) == 0 or any([
match.lower() in dev.get("host").lower()
for match in hostname_must_contains
]):
host_filtered_devices.append(dev)
if len(devices) > len(host_filtered_devices):
devices = host_filtered_devices
print("{} devices matches hostname filter(s)".format(len(devices)))
return msiempy.NitroList(alist=devices)
def get_mac_info(mac):
data = None
try:
query = manuf.MacParser(update=True)
data = query.get_manuf_long(mac)
except:
abort(400, 'Record not found')
if not data:
abort(404, "Not found")
return render_template('api/mac.html', data=data)
def getManuf(mac):
try:
from manuf import manuf
parser = manuf.MacParser(manuf_name='manuf/manuf')
print('\n')
m = parser.get_all(mac)
if m.manuf:
manufacture = '{} {}'.format(
m.manuf, '(' + m.comment + ')' if m.comment else '')
else:
manufacture = '-'
return manufacture
except:
return '-'
def run_detection():
while True:
full_results = [
re.findall('^[\w\?\.]+|(?<=\s)\([\d\.]+\)|(?<=at\s)[\w\:]+', i)
for i in os.popen('arp -a')
]
final_results = [
dict(zip(['IP', 'LAN_IP', 'MAC_ADDRESS'], i)) for i in full_results
]
final_results = [{
**i,
**{
'LAN_IP': i['LAN_IP'][1:-1]
}
} for i in final_results]
mac = [('MAC_ADDRESS' in final_results[i])
for i in range(len(final_results))]
local = [
final_results[i]['LAN_IP'][:3] == '192'
for i in range(len(final_results))
]
addr = [
final_results[i]['MAC_ADDRESS'] for i in range(len(final_results))
if mac[i] & local[i]
]
manu = []
for i in addr:
p = manuf.MacParser(update=True)
tup = p.get_manuf(i)
manu.append(tup)
device_list = []
for n in manu:
if n == None:
continue
if n == 'Apple':
d = {'name': 'iPhone X', 'traffic': '10'}
device_list.append(d)
if n == 'WyzeLabs':
d = {'name': 'WyzeCam', 'traffic': '10'}
device_list.append(d)
json_file['device_list'] = device_list
print(manu)
def updateClientsFile(f, tempfile, clients):
print("Updating clients.csv...")
fields = ['IP', 'COUNT', 'STATUS', 'MAC', 'VENDOR', 'TIMESTAMP']
reader = csv.DictReader(f, fieldnames=fields)
writer = csv.DictWriter(tempfile, fieldnames=fields)
header = next(reader) # = fields
writer.writerow(header)
row_list = list(reader)
ip_mac_list = []
for row in row_list:
info = {'ip': row['IP'], 'mac': row['MAC']}
ip_mac_list.append(info)
updated_rows = []
parser = manuf.MacParser(update=False)
for client in clients:
# New clients.
if client not in ip_mac_list:
row = {
'IP': client['ip'],
'COUNT': 1,
'STATUS': "ACTIVE",
'MAC': client['mac'],
'VENDOR': getVendor(client['mac'], parser),
'TIMESTAMP': str(datetime.now())[:16]
}
updated_rows.append(row)
# Updates old clients (COUNT++).
else:
idx = ip_mac_list.index(client)
old_count = int(row_list[idx]['COUNT'])
row_list[idx]['COUNT'] = old_count + 1
# Old but inactive clients.
for idx, old_client in enumerate(ip_mac_list):
if not any(client == old_client for client in clients):
row_list[idx]['STATUS'] = "INACTIVE"
else:
row_list[idx]['STATUS'] = "ACTIVE"
updated_rows += row_list
for row in updated_rows:
writer.writerow(row)
def main():
# sniff on specified channel
cmd = f'iw dev {args.interface} set channel {args.channel}'
try:
subprocess.check_call(cmd.split(' '))
except subprocess.CalledProcessError as c:
print(
f'Error: failed to switch to channel {args.channel} for interface {args.interface}',
file=sys.stderr)
sys.exit(-1)
update_vdb = False
global vendor_db
if not os.path.isfile(MANUF_FILE):
update_vdb = True
if update_vdb:
print('Updating and loading manuf file')
else:
print('Loading manuf file')
vendor_db = manuf.MacParser(manuf_name='./manuf', update=update_vdb)
# use a detached thread to process the queue and exit faster packet callback
pq = threading.Thread(target=process_queue, args=(queue, args))
pq.start()
print(
f':: Started listening to probe requests on channel {args.channel} on interface {args.interface}'
)
print('Hit CTRL-C to exit')
try:
sniff(iface=args.interface,
prn=build_packet_cb(config.IGNORED),
store=0,
filter='wlan type mgt subtype probe-req',
stop_filter=check_event)
except Scapy_Exception as se:
print(f'Error: {se}', file=sys.stderr)
sys.exit(-1)
except OSError as o:
print(f"Error: {args.interface} interface not found", file=sys.stderr)
sys.exit(-1)
finally:
event.set()
pq.join()
def run(self, args, cmd):
self.cmd = cmd
if args.mac_vendor_lookup:
self.mac_parser = manuf.MacParser(update=True)
driver = Graph(args.uri)
tx = driver.begin()
self._create_bss_nodes(tx)
tx.commit()
tx = driver.begin()
if args.aggregate_probes:
self._create_client_aggregated_nodes(tx, args.skip_empty_clients)
else:
self._create_client_nodes(tx, args.skip_empty_clients)
tx.commit()
cmd.pfeedback("[i] Neo4j dump completed.")
def fetchMacVendor(mac):
# This function looks up the vendor of a mac address.
# Returns None if unable to find it
try:
from manuf import manuf
except ImportError:
raise Exception('''manuf dependency not installed. \
This can be installed by running "pip install manuf"''')
import os
if not isValidMacAddress(mac):
return 'Not a valid mac address'
if not isMacInCorrectFormat(mac, "00:00:00:00:00:00"):
mac = change_mac_address_format(mac, "00:00:00:00:00:00")
p = manuf.MacParser(update=True)
vendor = p.get_all(mac).manuf
# delete the downloaded database to cleanup after ourselves
os.unlink('manuf')
return vendor
def get_mac_address_list(ip_address='192.168.1.1',
i_range=[1, 255],
hide_empty_macs=False,
hide_device_names=False) -> list:
device_parser = manuf.MacParser(update=False)
mac_address_list = []
ip_parts = ip_address.split('.')
get_device_ip()
for iter in range(i_range[0], i_range[1]):
current_ip = f'{ip_parts[0]}.{ip_parts[1]}.{ip_parts[2]}.{iter}'
mac_addr = get_mac_address(ip=current_ip, network_request=True)
mac_dict = {'ip': current_ip, 'mac': mac_addr, 'device': None}
if mac_addr != '00:00:00:00:00:00' and mac_addr != None:
device_name = device_parser.get_manuf_long(str(mac_addr))
if device_name != None:
mac_dict['device'] = "Not Available"
mac_address_list.append(mac_dict)
elif (hide_device_names != True):
mac_dict['device'] = "Not available"
mac_address_list.append(mac_dict)
elif (hide_empty_macs != True):
mac_dict['mac'] = "00:00:00:00:00:00"
mac_dict['device'] = "Not available"
mac_address_list.append(mac_dict)
elif (current_ip == get_device_ip()):
mac_addr = getmac.get_mac_address(
network_request=False, interface=current_network_interface)
device_name = device_parser.get_manuf_long(str(mac_addr))
mac_dict[
'ip'] = f'{ip_parts[0]}.{ip_parts[1]}.{ip_parts[2]}.{iter}'
mac_dict['device'] = "Not available"
mac_dict['mac'] = mac_addr
mac_address_list.append(mac_dict)
print('ARP table len: ', len(mac_address_list))
return mac_address_list
def macaddressconverter():
p = manuf.MacParser(update=True)
cursor.execute(
"""SELECT wlansa from dwccincoming WHERE wlansaconverted IS NULL OR wlansaconverted = '' limit 1;"""
)
mactochange = cursor.fetchone()
print "The mac that will be changed", mactochange
if mactochange is None:
print "all MAC matched to vendors"
else:
#This below will remove the punctuation for the VAR
mactochange = ''.join(c for c in mactochange
if c not in string.punctuation)
changedmac = p.get_manuf(mactochange)
changedmacstr = str(changedmac)
mactochangestr = str(mactochange)
#This below will write the mac vendor back to the database
cursor.execute("UPDATE dwccincoming SET wlansaconverted = " +
` changedmacstr ` + " WHERE wlansa = " +
` mactochangestr ` + " ;")
conn.commit()
macaddressconverter()
def __init__(self):
super().__init__()
self.host_list = []
self.db = QSqlDatabase.addDatabase('QSQLITE')
if not self.db.isValid():
print("Error: Invalid database.")
self.db.setDatabaseName('live_hosts.db')
if not self.db.open():
print("Error {}".format(self.db.lastError().text()))
self.db_table = 'live_hosts'
self.query = QSqlQuery()
if not self.query.exec_("DROP TABLE IF EXISTS live_hosts"):
print(self.query.lastError().text())
if not self.query.exec_(
"CREATE TABLE IF NOT EXISTS live_hosts(id INTEGER PRIMARY KEY,"
"ip_address TEXT NOT NULL UNIQUE, "
"mac_address TEXT NOT NULL, oui TEXT, status TEXT,"
"computer_name TEXT, user_text TEXT)"):
print(self.query.lastError().text())
self.table_view_model = MySqlTableModel()
self.table_view_model.setTable(self.db_table)
self.table_view_model.setHeaderData(1, Qt.Horizontal, "IP Address")
self.table_view_model.setHeaderData(2, Qt.Horizontal, "MAC Address")
self.table_view_model.setHeaderData(3, Qt.Horizontal, "Manufacturer")
self.table_view_model.setHeaderData(4, Qt.Horizontal, "Status")
self.table_view_model.setHeaderData(5, Qt.Horizontal, "Computer Name")
self.table_view_model.setHeaderData(6, Qt.Horizontal, "User Text")
self.table_view_model.select()
self.proxy_model = CustomSortingModel()
self.proxy_model.setSourceModel(self.table_view_model)
self.mac_parser = manuf.MacParser(update=False)
def __init__(self, config=None, queue=None):
self.log = logging.getLogger(inspect.stack()[0][1].split("/")[-1])
self.log.debug("profiler pid: %s; parent pid: %s", os.getpid(), os.getppid())
self.analyzed_hash = {}
self.config = config
if config:
self.channel = int(config.get("GENERAL").get("channel"))
self.ssid = config.get("GENERAL").get("ssid")
self.files_path = config.get("GENERAL").get("files_path")
self.pcap_analysis = config.get("GENERAL").get("pcap_analysis")
self.ft_disabled = config.get("GENERAL").get("ft_disabled")
self.he_disabled = config.get("GENERAL").get("he_disabled")
self.reports_dir = os.path.join(self.files_path, "reports")
self.clients_dir = os.path.join(self.files_path, "clients")
self.csv_file = os.path.join(
self.reports_dir, f"profiler-{time.strftime('%Y-%m-%d')}.csv"
)
self.client_profiled_count = 0
self.lookup = manuf.MacParser(update=False)
self.last_manuf = "N/A"
if queue:
while True:
self.profile(queue)
def prepare_mac_parser(self):
print("\033[H\033[J")
print(crayons.white("|>>>> Loading vendors from oui.."))
self._macparser = manuf.MacParser(update=True)
from sty import fg, bg, ef, rs
import os
from manuf import manuf
import socket
import threading
import time
arp_cache = dict()
hosts = dict()
kill = False
show = [
]
macmanuf = manuf.MacParser()
def prettyprint_QoS(host):
if len(host['signal']) > 120:
s0 = host['signal'][-120:]
else:
s0 = host['signal']
for s in s0[::-1]:
qos = int(list(s.values())[0])
if qos > -70:
print('█', end='')
elif qos > -80:
print('▄', end='')
elif qos > -90:
to_node = Node('manufacturer',
manuf_name=to_node_name[0],
manuf_comment=to_node_name[1])
if None in [from_node, to_node]:
raise Exception('Unknown connection type', connection)
rel = Relationship(from_node, connection, to_node)
graph.merge(rel)
def worker(mac_address):
print(mac_address)
manuf_data = mac_parser.get_all(mac_address)
if manuf_data is None or manuf_data.manuf is None:
return
register_connection('ETHER/GEN/OUI/MANUFACTURED_BY', mac_address,
(manuf_data.manuf, manuf_data.comment))
graph = Graph(
password='******') # TODO: parameterize, don't hardcode password
mac_parser = manuf.MacParser(update=True)
if __name__ == '__main__':
pool = multiprocessing.Pool(multiprocessing.cpu_count())
manuf.MacParser(update=True)
macs = [
_['d.mac_address'] for _ in graph.run(
'MATCH (d:device) WHERE NOT (d)-[:`ETHER/GEN/OUI/MANUFACTURED_BY`]-() RETURN d.mac_address'
)
]
pool.map(worker, macs)
def __init__(self, xml):
self.netxml = xmltodict.parse(xml)
self.networks = {}
self.manuf = manuf.MacParser(update=True)
def cpg(graph, stationDict, bssidDict):
#Add all of the Access Points discovered
mac = manuf.MacParser(update=MANUF_UPDATE)
for entry in bssidDict:
bssid = entry['BSSID']
essid = entry['ESSID']
speed = entry['Speed']
channel = entry['channel']
auth = entry['Authentication']
cipher = entry['Cipher']
lan = entry["LAN IP"].replace(" ", "")
priv = entry["Privacy"]
if lan == "0.0.0.0":
lan = ""
if len(essid) == 0:
essid = bssid
lookup = mac.get_all(bssid)
if lookup[1] is not None:
oui = lookup[1]
else:
oui = lookup[0]
if oui is None:
oui = "Private"
if "WPA2" in priv:
b = Node("WPA2",
name=essid,
bssid=bssid,
OUI=oui,
Encryption="WPA2",
speed=speed,
channel=channel,
auth=auth,
cipher=cipher,
lan=lan)
elif "WPA" in priv:
b = Node("WPA",
name=essid,
bssid=bssid,
OUI=oui,
Encryption="WPA",
speed=speed,
channel=channel,
auth=auth,
cipher=cipher,
lan=lan)
elif "WEP" in priv:
b = Node("WEP",
name=essid,
bssid=bssid,
OUI=oui,
Encryption="WEP",
speed=speed,
channel=channel,
auth=auth,
cipher=cipher,
lan=lan)
elif "OPN" in priv:
b = Node("Open",
name=essid,
bssid=bssid,
OUI=oui,
Encryption="None",
speed=speed,
channel=channel,
auth=auth,
cipher=cipher,
lan=lan)
else:
b = Node("AP",
name=essid,
bssid=bssid,
OUI=oui,
Encryption="None",
speed=speed,
channel=channel,
auth=auth,
cipher=cipher,
lan=lan)
graph.create(b)
#Parse list of clients and add probe relations
for item in stationDict:
essids = item['Probed ESSIDs'].split(",")
station = item['Station MAC']
fts = item['First time seen']
lts = item['Last time seen']
pwr = item['Power']
pkts = item['# packets']
if item['BSSID'] != "(not associated)":
bssid = item['BSSID']
else:
bssid = None
lookup = mac.get_all(station)
if lookup[1] is not None:
oui = lookup[1]
else:
oui = lookup[0]
if oui is None:
oui = "Private"
s = Node("Client",
name=station,
FirstTimeSeen=fts,
LastTimeSeen=lts,
Power=pwr,
NumPackets=pkts,
Association=bssid,
OUI=oui)
for essid in essids:
for label in ["AP", "Open", "WEP", "WPA", "WPA2"]:
existing = graph.nodes.match(label, name=essid).first()
if existing is not None:
break
if len(essid) > 0:
if existing is not None:
e = existing
else:
e = Node("AP", name=essid)
se = Relationship(s, "Probes", e)
graph.create(se)
# AP Additions per Client
if bssid is not None:
# If AP already exists by name, use existing node. Else create new.
b = None
for label in ["AP", "Open", "WEP", "WPA", "WPA2"]:
existing = graph.nodes.match(label, bssid=bssid).first()
if existing is not None:
b = existing
break
else:
b = Node("AP", bssid=bssid)
probeSb = Relationship(s, "Probes", b)
sb = Relationship(s, "AssociatedTo", b)
graph.create(sb)
from flask import Blueprint, request, Flask
from manuf import manuf
import time
import sys
bp = Blueprint("api", __name__, url_prefix="/api")
mp = manuf.MacParser(update=True)
app = Flask(__name__)
@bp.route("/<mac>", methods=[
"GET",
])
def mac_lookup(mac):
if request.method == "GET":
return mp.get_all(mac)
@bp.route("/manufacturer/<mac>", methods=[
"GET",
])
def mac_lookup_manufacturer(mac):
if request.method == "GET":
return mp.get_manuf(mac)
@bp.route("/comment/<mac>", methods=[
"GET",
])
def mac_lookup_comment(mac):
if request.method == "GET":
nrows=1)
df5 = pd.read_csv(
f'{filename}',
names=colnames,
skip_blank_lines=True,
header=None,
skipinitialspace=0,
engine='python',
dtype=str,
skiprows=5,
usecols=range(7)).dropna().drop_duplicates("Probed ESSIDs")
df6 = pd.read_csv(
f'{filename}', names=colnames, skiprows=14,
usecols=range(7)).dropna().drop_duplicates("Probed ESSIDs")
# Set to True, to refresh the MAC address DB
p = manuf.MacParser(update=False)
for row, series in df2.iterrows():
print('\n' * 0)
print("Wireless Network Name:")
print(Fore.RED + series["ESSID"])
print('\n' * 0)
for row, series in df3.iterrows():
print("Wireless Network Type:")
print(Fore.RED + series["Privacy"])
for row, series in df4.iterrows():
print('\n' * 0)
print("Wireless Network Authentication in use:")
print(Fore.RED + series["Authentication"])
print('\n' * 0)
print("Clients on network and corresponding MAC Addresses:")
print('\n' * 0)
