def extract_devices(self):
"""
Extract devices from the captured packets.
Returns:
pandas.DataFrame:
Device parameters extracted from the captured packets.
"""
devs = pd.DataFrame(
columns=["MAC", "Vendor", "Times", "Frame Subtypes"])
if (self.packets.empty):
return devs
macs = self.packets["MAC"].unique()
ML = MacLookup()
ML.update_vendors()
for mac in macs:
frames = self.packets.loc[self.packets["MAC"] == mac]
if (mac[1] == "2" or mac[1] == "6" or mac[1] == "a"
or mac[1] == "e" or mac[1] == "A" or mac[1] == "E"):
vendor = "Randomized"
else:
try:
vendor = ML.lookup(mac)
except KeyError:
vendor = "Unknown"
mins = np.unique(
np.array([(60 * tm.hour + tm.minute)
for tm in frames["Time"]]))
subtypes = frames["Frame Subtype"].unique()
devs.loc[len(devs)] = [mac, vendor, mins, subtypes]
return devs
def get_manufacturer(mac):
search_manufacturer = MacLookup()
try:
manufacture = search_manufacturer.lookup(mac)
except:
manufacture = "Unknown"
return manufacture
def get_hosts():
scanner = nmap.PortScanner()
print("starting scan")
start = time.time()
scanner.scan("172.16.80.0/23", "22", arguments="-n")
print("completed scan", round(time.time() - start, 2))
addresses = scanner.all_hosts()
vendor_lookup = MacLookup()
local_interface_map = get_local_ipv4_interface_map()
hosts = []
print("getting mac address of network cards")
start = time.time()
for address in addresses:
mac = get_mac_address(ip=address)
if not mac and address in local_interface_map:
mac = get_mac_address(interface=local_interface_map[address])
try:
vendor = vendor_lookup.lookup(mac) if mac else None
except KeyError:
print("error processing mac for", address)
hosts.append({"ip": address, "mac": mac, "vendor": vendor})
print("mac address acquired", round(time.time() - start, 2))
return hosts
def network_device_list(host, token, headers, mac):
url = "https://" + host + "/dna/intent/api/v1/client-detail?timestamp&macAddress=" + mac
headers["x-auth-token"] = token
response = requests.get(url, headers=headers, verify=False)
#print(response)
data = response.json()
#print(json.dumps(data, sort_keys=True, indent=4, separators=(',', ':')))
#print(json.dumps(data['topology']['nodes'], sort_keys=True, indent=4, separators=(',', ':')))
try:
print(mac, data['topology']['nodes'][0]['ip'],
(MacLookup().lookup(mac)))
except KeyError:
print(mac, ' No Data')
filename = 'H:/CSV_ISE_Stuff/NDOT_IP.csv'
write_header = not os.path.exists(filename)
with open(filename, 'a', newline='') as csvfile:
headers = ['MAC Address', 'IP Address', 'OUI']
writer = csv.DictWriter(csvfile, fieldnames=headers)
if write_header:
writer.writeheader()
writer = csv.writer(csvfile)
try:
csvdata = (mac, data['topology']['nodes'][0]['ip'],
(MacLookup().lookup(mac)))
except KeyError:
csvdata = (mac, ' No Data')
writer.writerow(csvdata)
def find_mac(mac_addr):
mac_data = MacLookup()
mac_data.update_vendors()
try:
return mac_data.lookup(mac_addr)
except KeyError:
return "Unknown"
class NmapMacScan(NmapBasic):
def __init__(self, networks, unknown="unknown"):
super().__init__(networks)
self.unknown = unknown
self.mac_search = MacLookup()
def update_mac(self, ip):
"""
Update Mac info
:param ip: IP address (ie: 192.168.1.1)
:return: True if MAC is found, False otherwise
"""
mac = getmac.get_mac_address(ip=ip)
if mac is None:
return False
else:
self.scan_results[ip]["macaddress"] = mac
return True
def update_vendor(self, ip):
"""
Update MAC vendor if Mac is found
:param ip: IP address (ie: 192.168.1.1)
:return: None
"""
logging.debug("Updating MAC table")
self.mac_search.update_vendors()
vendor_fetch = self.mac_search.lookup(
self.scan_results[ip]["macaddress"])
self.scan_results[ip]["vendor"] = vendor_fetch
def correct_missing_mac(self, host):
"""
Correct description if macaddress is not found
:param host: host key in scan_results
:return: None
"""
if not self.scan_results[host]["macaddress"]:
self.scan_results[host]["description"] = self.unknown
self.scan_results[host].pop("macaddress")
def scan(self):
"""
Scan defined networks and conditionally check for mac vendor
:return: scan_results = list()
"""
for host, v in self.scan_results.items():
if v.get("macaddress") or self.update_mac(host):
self.update_vendor(ip=host)
self.correct_missing_mac(host)
return self.scan_results
def run(self):
return self.scan()
def create_mac_table(key, lst, lookup=False):
td = [[key]]
if lookup:
td[0].append("vendor")
m = MacLookup()
for i in lst:
try:
if lookup:
td.append([i, m.lookup(i)])
else:
td.append([i])
except Exception:
td.append([i, ""])
return td
def choose_target():
subprocess.call("clear", shell=True)
print("------------" + Fore.YELLOW + " Choose a Target " + Fore.WHITE +
"------------")
global results
for x in range(len(results)):
try:
vendor = MacLookup().lookup(results[x]["mac"])
except:
vendor = "UNKNOWN"
print(
str(x) + ") " + results[x]["ip"] + " \t[" + results[x]["mac"] +
"] \t[" + vendor + "]")
try:
choice = input("\nChoose Target: ")
except KeyboardInterrupt:
print(Fore.CYAN + "\n[+]" + Fore.WHITE + " Stopping...")
subprocess.call("echo 0 > /proc/sys/net/ipv4/ip_forward", shell=True)
exit(0)
try:
int(choice)
except:
print(Fore.RED + "[+]" + Fore.WHITE + " Error: Invalid Input!")
subprocess.call("echo 0 > /proc/sys/net/ipv4/ip_forward", shell=True)
exit(0)
if int(choice) in range(len(results)):
return results[int(choice)]
else:
print(Fore.RED + "[+]" + Fore.WHITE + " Error: Choice Invalid!")
subprocess.call("echo 0 > /proc/sys/net/ipv4/ip_forward", shell=True)
exit(0)
def store_device_info(self, device_info):
"""Gather and store the FQDN and vendor-name to make a dictionary for each device containing that information."""
if (self.os == "Windows" and device_info[-1] == "static"):
self.static_addrs.append(device_info)
if (self.os != "Windows"):
# removing the name for Mac/Linux to normalize the list across OS's
self.device_info.remove(device_info[0])
self.device_info[0] = device_info[0].replace('(', '')
self.device_info[0] = device_info[0].replace(')', '')
mac_addr = self.fix_mac_addr(device_info[1])
ip = device_info[0]
self.name = socket.getfqdn(ip)
if (self.name == ip):
self.name = "Unknown_" + str(self.idx)
self.idx += 1
else:
pass
try:
self.mac_name = MacLookup().lookup(mac_addr)
except:
pass
self.device_dict[self.name] = device_info
def scanNetwork(network):
user_ip = network
network = network + "/24"
network_list = []
global found_hosts
nm = nmap.PortScanner()
a = nm.scan(hosts=network, arguments='-sn')
with open('../scanlog.txt', 'w') as file:
file.write(json.dumps(json.loads(json.dumps(a)), indent=4))
for k, v in a['scan'].items():
if str(v['status']['state']) == 'up':
ip4 = str(v['addresses']['ipv4'])
hostname = str(v['hostnames'][0]['name'])
mac_addr = get_mac_address(ip=ip4)
if not hostname:
hostname = "No hostname found"
if not mac_addr and ip4 == user_ip:
mac_addr = get_mac_address()
if mac_addr:
try:
vendor_name = MacLookup().lookup(mac_addr)
except KeyError:
vendor_name = 'No vendor found'
else:
mac_addr = 'Your Interface'
vendor_name = 'Your Interface'
if ip4 == user_ip:
vendor_name += " (Your Interface)"
network_list.append([ip4, mac_addr, hostname, vendor_name])
found_hosts.append([ip4, hostname])
return network_list
def translatetoconfig(confline):
"""Parse an ISC DHCP reservation, and return ISC config format with
reservation as an IPv4 address"""
if confline.lstrip().startswith('host'):
# Translate this line
try:
if confformat.match(confline):
spaces, hostname, reservation, mac = confformat.findall(
confline)[0]
mac_vendor = '"' + MacLookup().lookup(mac) + '"'
else:
return ('ERROR')
except ValueError:
hostname, reservation, mac = 'LINEERROR', 'LINEERROR', 'LINEERROR'
except IndexError:
hostname, reservation, mac = 'LINEERROR', 'LINEERROR', 'LINEERROR'
if ipformat.match(reservation):
ipaddress = reservation
else:
try:
ipaddress = gethostbyname(reservation)
except Exception:
ipaddress = '0.0.0.0'
return(spaces + 'host ' + hostname + ' {fixed-address ' + ipaddress + \
'; hardware ethernet ' + mac + ';}')
#return([ipaddress, mac, mac_vendor, hostname, reservation, confline])
#return(','.join([ipaddress, mac, hostname, reservation, confline]))
else:
# Return this line unmodified (it's not a DHCP reservation)
return (confline)
class MacAddresses:
def __init__(self):
self.__mac_lookup = MacLookup()
self.__mac_lookup.load_vendors()
self.__mac_addresses = self.__fetch_mac_addresses()
def __call__(self):
return self.__mac_addresses
# MACアドレスの取得
def __fetch_mac_addresses(self):
mac_addresses = {}
for name, interface in ifcfg.interfaces().items():
address = interface['ether']
mac_addresses[name] = {
'address':
address,
'vendor':
self.__lookup_org_by_mac_address(address)
if address is not None else None,
}
return mac_addresses
# MACアドレスからベンダを照会する
# mac_vendor_lookupが存在しないMACアドレスを投げると例外吐いて死にやがるのでこういう邪悪なコードになりました
def __lookup_org_by_mac_address(self, mac_address):
oui = MacAddresses.translate_oui(mac_address)
return self.__mac_lookup.lookup(
mac_address
) if oui in self.__mac_lookup.async_lookup.prefixes else None
# MACアドレスからOUIを抽出して返す
@staticmethod
def translate_oui(mac_address):
oui = mac_address.replace(':', '').replace('-', '').upper()
try:
int(oui, 16)
except ValueError:
raise InvalidMacAddressException(
'{} contains unexpected character'.format(mac_address))
if len(oui) > 12:
raise InvalidMacAddressException(
'{} is not a valid MAC address (too long)'.format(mac_address))
if type(oui) == str:
oui = oui.encode('utf8')
return oui[:6]
def get_mac_vendor(mac):
try:
#create an instance of an object to search for the vendor
mac_vendor = MacLookup().lookup(mac)
#return the vendor mac address
except:
mac_vendor = "Unknown Vendor"
return mac_vendor
def render_mac_address(mac):
mac_parts = re.findall('..', mac)
mac_address = ":".join(mac_parts).upper()
mac_address_vendor = MacLookup().lookup(mac_address)
write_log_line("[{}] MAC Address: {}, MAC Address Vendor: {}".format(
request.remote_addr, mac_address, mac_address_vendor))
return render_template("mac_address.html",
mac_address=mac_address,
mac_address_vendor=mac_address_vendor)
def __init__(self, ip, mac, hostname):
self._ip = ip
self._mac = mac
self._hostname = hostname
try:
self._vendor = "UNKNOWN" if mac == "00:00:00:00:00:00" else MacLookup(
).lookup(self._mac)
except:
self._vendor = "UNKNOWN"
logging.info("New host created [IP: {}, MAC: {}, Vendor: {}]".format(
self._ip, self._mac, self._vendor))
self._services = []
def IpScanNetwork(Ini, End, speed):
if speed == "fast":
Speed = 0.3
elif speed == "low":
Speed = 4
r = {}
with open('return/Ips.json', 'w') as json_file:
json.dump(r, json_file, indent=4)
with open('return/Ips.json') as f:
fre = json.load(f)
inicial = IPv4Address(Ini)
final = IPv4Address(End)
o = 0
ips = [str(IPv4Address(ip)) for ip in range(int(inicial), int(final))]
try:
for ip in ips:
t = ping(ip, timeout=Speed)
status = False if t is None else True
if status:
o = o + 1
print(f'IP: {ip} [{status}]')
try:
eth_mac = get_mac_address(interface="eth0")
win_mac = get_mac_address(interface="Ethernet 3")
ip_mac = get_mac_address(ip=ip)
ip6_mac = get_mac_address(ip6="::1")
host_mac = get_mac_address(hostname="localhost")
updated_mac = get_mac_address(ip="10.0.0.1",
network_request=True)
getmac.PORT = 44444
mac = getmac.get_mac_address(ip=ip, network_request=True)
fabri = MacLookup().lookup(mac)
result = {
"Ip": ip,
"Status": status,
"mac": mac,
"fabri": fabri
}
fre[f"Scan{o}"] = result
except AttributeError:
print('Cod: 703')
return "Network Erro 02 703"
with open('return/ips.json', 'w') as json_file:
json.dump(fre, json_file, indent=4)
json_file.close()
except PermissionError:
print('Cod: 359')
def scan(ip):
arpRequest = scapy.ARP(pdst=ip)
broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arpRequestBroadcast = broadcast / arpRequest
answered = scapy.srp(arpRequestBroadcast, timeout=1, verbose=False)[0]
print(
"IP\t\t\tMAC Address\t\t\tVendor\n-----------------------------------------------------------"
)
for el in answered:
print(el[1].psrc + "\t\t" + el[1].hwsrc + "\t\t" +
MacLookup().lookup(el[1].hwsrc))
class maclookup():
def __init__(self):
self.async_mac = AsyncMacLookup()
self.mac = MacLookup()
def UpdateVendorList(self):
print("Updating MAC address vendor list")
self.mac.update_vendors()
print("MAC address vendor list has been updated")
def lookup(self, addr):
try:
loop = asyncio.get_event_loop()
vendor = loop.run_until_complete(self._lookup(addr))
return vendor
except Exception as e:
print(e)
print(addr)
async def _lookup(self, mac_addr):
return await self.async_mac.lookup(mac_addr)
def network_device_list(host, token, headers, mac):
url = "https://" + host + "/dna/intent/api/v1/client-detail?timestamp&macAddress=" + mac
headers["x-auth-token"] = token
response = requests.get(url, headers=headers, verify=False)
#print(response)
data = response.json()
#print(json.dumps(data, sort_keys=True, indent=4, separators=(',', ':')))
#print(json.dumps(data['topology']['nodes'], sort_keys=True, indent=4, separators=(',', ':')))
try:
#print (mac,' IP of Device ',data['detail']['hostIpV4'],' Switch Name ',data['detail']['clientConnection'],' port ',data['detail']['port'])
print(mac, data['topology']['nodes'][0]['ip'],
(MacLookup().lookup(mac)), 'Switch',
data['detail']['clientConnection'], 'Switch IP',
data['topology']['nodes'][1]['ip'], 'Port',
data['detail']['port'])
except KeyError:
print(mac, 'No Data')
filename = 'H:/Scripts/DNA/' + name + '.csv'
write_header = not os.path.exists(filename)
with open(filename, 'a') as csvfile:
headers = [
'MAC Address', 'IP Address', 'OUI', 'Device Name', 'Switch IP',
'Port ID'
]
writer = csv.DictWriter(csvfile, fieldnames=headers)
if write_header:
writer.writeheader()
writer = csv.writer(csvfile)
try:
csvdata = (mac, data['topology']['nodes'][0]['ip'],
(MacLookup().lookup(mac)),
data['detail']['clientConnection'],
data['topology']['nodes'][1]['ip'],
data['detail']['port'])
except KeyError:
csvdata = (mac, 'No Data')
writer.writerow(csvdata)
def scan(ip):
request = scapy.ARP(pdst=ip)
broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
broadcast_request = broadcast / request
ans_ls, unans_ls = scapy.srp(broadcast_request, timeout=1, verbose=False)
ip_mac_list = []
for answer in ans_ls:
ip_mac_dict = {
"ip": answer[1].psrc,
"mac": answer[1].hwsrc,
"vendor": MacLookup().lookup(str(answer[1].hwsrc))
}
ip_mac_list.append(ip_mac_dict)
return ip_mac_list
def displayInterfaceInfo(interface_name):
print(color("\n" + "-" * 30, Colors.green))
print(
color("Interface: ", Colors.green) + color(interface_name, Colors.red))
print(
color("IP-Address: ", Colors.green) +
color(get_ip_address(interface_name), Colors.red))
print(
color("MAC-Address: ", Colors.green) +
color(get_mac_address(interface_name), Colors.red))
print(
color("Vendor: ", Colors.green) + color(
(MacLookup().lookup(get_mac_address(interface_name))), Colors.red))
print(color("-" * 30, Colors.green))
def network_device_list(host, token, headers, mac):
url = "https://" + host + "/dna/intent/api/v1/client-detail?timestamp&macAddress=" + mac
headers["x-auth-token"] = token
response = requests.get(url, headers=headers, verify=False)
#print(response)
data = response.json()
#print(json.dumps(data, sort_keys=True, indent=4, separators=(',', ':')))
#print(json.dumps(data['topology']['nodes'], sort_keys=True, indent=4, separators=(',', ':')))
try:
#print (mac,' IP of Device ',data['detail']['hostIpV4'],' Switch Name ',data['detail']['clientConnection'],' port ',data['detail']['port'])
print(mac, data['detail']['hostIpV4'], (MacLookup().lookup(mac)))
except KeyError:
print(mac, ' Not_in_DNA-C')
def _network_widget(self, profile: str) -> Markup:
table_data: list = list()
# noinspection PyPep8Naming
WIDGET = "network"
user_profile = _get_profile(profile, WIDGET)
card_classes = [
_widget_visible(user_profile.widgets.network.display_widget)
]
self.widget_visibility.update(
{"network": user_profile.widgets.network.display_widget})
network_data_list = self.get_network()["data_list"]
for interface_data in network_data_list:
ip: IPv4Interface = ipaddress.ip_interface(
f"{interface_data['ipv4']}/{interface_data['netmask']}")
try:
vendor = MacLookup().lookup(interface_data["mac address"])
except (KeyError, InvalidMacError):
vendor = None
if interface_data["ipv4"] != "127.0.0.1" and interface_data["ipv4"] \
and not ip.is_link_local and vendor:
for key, value in interface_data.items():
display_name = key.title()
display_value = None
if "dns" in key.lower():
display_name = key.lower().replace("dns", "DNS")
elif "dhcp" in key.lower():
display_name = key.lower().replace("dhcp", "DHCP")
elif "mac" in key.lower():
display_name = key.title().replace("Mac", "MAC")
elif "state" in key.lower():
display_value = _interface_state(value)
elif "speed" in key.lower():
display_value = _interface_speed(value)
elif key.lower().startswith("ip"):
display_name = key.lower().replace("ip", "IP")
if "ipv4" in key.lower():
display_value = ip.with_prefixlen
row_content = self._table_row_head % {"head_class": "", "head_content": display_name} + \
self._table_data % {"cell_class": "", "cell_content": display_value or value}
table_data.append(
self._generate_table_row(
key, user_profile.widgets.network.display_fields,
row_content))
return self._generate_std_widget(WIDGET.title(), table_data,
card_classes)
def netScan(self, port):
open = []
tcpPorts = []
udpPorts = []
mac = []
macVendor = []
ipAddr = []
deviceScanner = Discover()
print("=================================")
print("Scanning local network and ports")
print("=================================")
print("Host IP: " + str(self.hostIP))
ipRange = self.ipBase + "/16"
print("[+] IP RANGE [" + str(ipRange) + "]")
print("++++++++++++++++++++++++++++++++++++++")
try:
allDevices = deviceScanner.scan(ip_range=ipRange)
for device in allDevices:
ipAddr.append(device['ip'].decode('ASCII'))
try:
mac.append(device['mac'].decode('ASCII'))
macVendor.append(MacLookup().lookup(
device['mac'].decode('ASCII')))
except:
macVendor.append("None")
try:
open.append(
portScanner.portScanner(device['ip'].decode('ASCII'),
port))
except:
print("While scanning ports , got an error!")
try:
for i in range(len(open)):
tcpPorts.append(open[i].opentcp)
udpPorts.append(open[i].openudp)
for i in range(len(mac)):
db.insertinto(self.hostIP, mac[i], ipAddr[i], macVendor[i],
tcpPorts[i], udpPorts[i])
self.createTable(ipAddr, mac, macVendor, tcpPorts, udpPorts)
except:
print("Got an error while creating table")
except:
print("Got error while getting IP Addresses!")
class DHCPDLogEntry(LogEntry):
mac_regex = re.compile(r'''([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})''')
mac_lookup = MacLookup()
def __init__(self, line):
super().__init__(line)
self.line = line.split('dhcpd: ')[1]
result = re.search(DHCPDLogEntry.mac_regex, line)
if result:
mac = result.group(0)
try:
vendor = DHCPDLogEntry.mac_lookup.lookup(mac)
self.line += f' ({vendor})'
except:
self.line += ' (unknown vendor)'
def __str__(self):
return self.line
def _method_(self, *args):
try:
options = args[0]
ip = options[0]
except IndexError:
print('[-] Check if options are correct. [ip/24]')
arpRequest = scapy.ARP(pdst=ip)
broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arpRequestBroadcast = broadcast / arpRequest
answered = scapy.srp(arpRequestBroadcast, timeout=1, verbose=False)[0]
print(
"IP\t\t\tMAC Address\t\t\tVendor\n-----------------------------------------------------------"
)
for el in answered:
print(el[1].psrc + "\t\t" + el[1].hwsrc + "\t\t" +
MacLookup().lookup(el[1].hwsrc))
def ARPScan(IP):
arp_request = scapy.ARP()
arp_request.pdst = IP # setting the IPfield in Scapy ARP packet to IP
broadcast = scapy.Ether()
broadcast.dst = "ff:ff:ff:ff:ff:ff"
arp_request_broadcast = broadcast / arp_request
answered_list, unanswered_list = scapy.srp(arp_request_broadcast,
timeout=2,
verbose=False)
clients_list = []
for answer in answered_list:
RetrievedMACVendor = MacLookup().lookup(answer[1].hwsrc)
client_dict = {
"ip": answer[1].psrc,
"mac": answer[1].hwsrc,
"mac_vendor": RetrievedMACVendor
}
clients_list.append(client_dict)
return clients_list
def getLiveConnexion():
print("Starting monitoring mode...")
cap = pyshark.LiveCapture(interface='wlan0mon',
display_filter='wlan.fc.subtype==0x0004')
print("Listening for beacon packets..")
list_of_probes = []
list_of_detected_devices = []
while (True):
list_of_detected_devices.clear()
list_of_probes.clear()
start = time.time()
end = 0
for packet in cap.sniff_continuously():
# Si l'adresse mac a deja etait detctée une fois, on saut ce packet.
if packet.wlan.sa_resolved in list_of_detected_devices:
continue
else:
list_of_detected_devices.append(packet.wlan.sa_resolved)
puissance = -34
rssi = int(packet.radiotap.dbm_antsignal)
distance = pow(10, (puissance - rssi) / 20)
vendor = MacLookup().lookup(packet.wlan.sa_resolved)
probe = {
"created_at": "{}".format(datetime.now()),
"field1": packet.wlan.sa_resolved,
"field2": packet.radiotap.dbm_antsignal,
"field3": distance,
"field4": vendor
}
list_of_probes.append(probe)
end = time.time()
#For the "for" loop.
if end - start > 16:
break
print(list_of_probes)
def catalogNetwork(conn, cursor, surveyResults):
networkId = getNetworkId(surveyResults, conn, cursor)
cursor.execute('SELECT * FROM hosts WHERE networkId = ?',
[networkId])
hosts = { host['macAddr'] : host
for host in cursor.fetchall() }
for host in surveyResults:
notRecorded = (host['mac'] not in hosts.keys())
#Does db ip match survey ip? (can differ in dynamic-addressed networks)
wrongIp = (0 if notRecorded
else (hosts[host['mac']]['ipAddr'] != host['ip']))
if notRecorded or wrongIp:
try:
manufacturer = MacLookup().lookup(host['mac'])
except:
manufacturer = 'unknown'
#Upsert.
cursor.execute('''INSERT OR ABORT INTO hosts
(macAddr, ipAddr, manufacturer, networkId) VALUES (?, ?, ?, ?)
ON CONFLICT(macAddr, networkId) DO UPDATE SET ipAddr = ?;''',
[host['mac'], host['ip'], manufacturer, networkId, host['ip']])
hosts[host['mac']] = {
'id': cursor.lastrowid,
'macAddr': host['mac'],
'ipAddr': host['ip'],
'manufacturer': manufacturer,
'networkId': networkId,
'notificationEnabled': 0,
'tone': 0
}
conn.commit()
#Make dict w/ hostId as key rather than mac.
retHosts = { host['id'] : host for _, host in hosts.items() }
return retHosts
def NetworkTara(ip_araligi):
cevaplar = []
modemmac = ""
nm = nmap.PortScanner()
print("Ag Taraniyor... Lutfen Bekleyiniz...")
a = nm.scan(ip_araligi, arguments='-sn')
for k, v in a['scan'].items():
if str(v['status']['state']) == 'up':
try:
cevaplar.append(
[str(v['addresses']['ipv4']),
str(v['addresses']['mac'])])
except:
pass
if len(cevaplar) == 0:
print("Host bulunamadi!")
else:
print("\n * * * * * * Blunan Hostlar * * * * * * ")
for i in range(len(cevaplar)):
if (cevaplar[i][0] == GetGateWay()):
modemmac = cevaplar[i][1]
print("[", i, "]", " - Ip :", cevaplar[i][0], "- Mac :",
cevaplar[i][1], "- Uretici Firma :",
MacLookup().lookup(cevaplar[i][1]))
hedef = int(input("Hedefin numarasi : "))
#giden bilgilerin formatı = [hedef_ip,hedef_mac,modemin_ip,modemin_mac]
giden_bilgiler = [
cevaplar[hedef][0], cevaplar[hedef][1],
GetGateWay(), modemmac
]
return giden_bilgiler
