Python netifaces.ifaddresses函数代码示例

def ip_addresses():
    """Find the IP addresses of the divices that look at file.

    TODO: Make code so that when any divice is looking for data
        logalyzer can find ip address and email to device, if the
        ip address is seen multiple times then anotheremail is not
        sent to device.

    Returns:
        ip_list: the list with the ip addresses
    """
    # list for ip addresses
    ip_list = []

    # Interate over available interfaces
    for interface in netifaces.interfaces():
        # Ignore interfaces with no data
        if bool(netifaces.ifaddresses(interface)) is False:
            continue

        # IPv4 addresses ALWAYS have a key of netifaces.AF_INET (2)
        # Make sure this is the case for this interface
        if netifaces.AF_INET in netifaces.ifaddresses(interface):
            # Hooray we have an IPv4 address! Add it to the list
            for interface_data in netifaces.ifaddresses(
                    interface)[netifaces.AF_INET]:
                ip_list.append(interface_data['addr'])

    # Return
    return ip_list

 def _detect(self):
     """uses the netifaces module to detect ifconfig information"""
     theip = None
     try:
         if self.opts['family'] == 'INET6':
             addrlist = netifaces.ifaddresses(self.opts['iface'])[netifaces.AF_INET6]
         else:
             addrlist = netifaces.ifaddresses(self.opts['iface'])[netifaces.AF_INET]
     except ValueError as exc:
         log.error("netifaces choked while trying to get network interface"
                   " information for interface '%s'", self.opts['iface'],
                   exc_info=exc)
     else:  # now we have a list of addresses as returned by netifaces
         for pair in addrlist:
             try:
                 detip = IPy.IP(pair['addr'])
             except (TypeError, ValueError) as exc:
                 log.debug("Found invalid IP '%s' on interface '%s'!?",
                           pair['addr'], self.opts['iface'], exc_info=exc)
                 continue
             if self.netmask is not None:
                 if detip in self.netmask:
                     theip = pair['addr']
                 else:
                     continue
             else:
                 theip = pair['addr']
             break  # we use the first IP found
     # theip can still be None at this point!
     self.set_current_value(theip)
     return theip

    def find_ip(iface):
        if not iface or iface == "any":
            return ("0.0.0.0", "")

        if_ip4 = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]["addr"]
        if_ip6 = netifaces.ifaddresses(iface)[netifaces.AF_INET6][0]["addr"]
        return (if_ip4, if_ip6)

def main(iface):
    # Get IP and mask
    ipHost = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['addr']
    mask = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['netmask']

    # Calculate the CIDR value
    maskCIDR = maskToCIDR(mask)

    tlwpa4230pIPs = []

    network = ipaddress.ip_network('{}/{}'.format(ipHost, maskCIDR), strict=False)
    print ('-- Scanning {} addresses...'.format(network.num_addresses - 2))

    for addr in network.hosts():
        # Check if the addr belongs to a TL-WPA4230P powerline adapter
        res = checkTLWPA4230P(str(addr))

        if res:
            print('{} is a TL-WPA4230P powerline adapter!'.format(str(addr)))
            tlwpa4230pIPs.append(str(addr))

    print('-- Scan completed.')

    # Open the web interface of the powerline adapters found
    for ip in tlwpa4230pIPs:
        print('Opening {} in web browser...'.format(ip))
        xdgOpenProcess = subprocess.Popen(['xdg-open', 'http://{}'.format(ip)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        xdgOpenProcess.wait()

    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!')

    def find_ip(iface):
        if not iface or iface == 'any':
            return ('0.0.0.0','')

        if_ip4 = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['addr']
        if_ip6 = netifaces.ifaddresses(iface)[netifaces.AF_INET6][0]['addr']
        return (if_ip4, if_ip6)

def get_commotion_client_ip():
    """Check interfaces for a valid commotion client IP address"""
    # Will interface impact commotion tests
    commotion_interfaces = {}
    commotion_client_ip = None
    # Raw list of interfaces
    # Could be rewritten as for __, iface in enumerate(ni.interfaces())
    interfaces = ni.interfaces()
    for iface in interfaces:
        try:
            if ni.ifaddresses(iface)[2][0]['addr'].startswith('10.'):
                print(iface + " has a valid Commotion IP address: " \
                    + ni.ifaddresses(iface)[2][0]['addr'])
                commotion_client_ip = ni.ifaddresses(iface)[2][0]['addr']
            else:
                commotion_interfaces[iface] = False
                print(iface + " not valid")
        except KeyError:
            commotion_interfaces[iface] = True
            print(iface + " has been disconnected")
            continue

    try:
        commotion_client_ip
    except (exceptions.CommotionIPError, KeyError) as args:
        print(args)

    # This should only return one thing. Move interfaces somewhere else!
    return commotion_interfaces, commotion_client_ip

def getLocalIP():
    if _platform == "darwin":
        interfaceName = "en0"
    else:
        interfaceName = "eth0"
    netifaces.ifaddresses(interfaceName)    
    return netifaces.ifaddresses(interfaceName)[2][0]['addr']

 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))

    def _update_widgets(self, widgets):
        interfaces = [ i for i in netifaces.interfaces() if not i.startswith(self._exclude) ]

        for widget in widgets:
            widget.set("visited", False)

        for intf in interfaces:
            addr = []
            state = "down"
            try:
                if netifaces.AF_INET in netifaces.ifaddresses(intf):
                    for ip in netifaces.ifaddresses(intf)[netifaces.AF_INET]:
                        if "addr" in ip and ip["addr"] != "":
                            addr.append(ip["addr"])
                            state = "up"
            except Exception as e:
                addr = []
            widget = self.widget(intf)
            if not widget:
                widget = bumblebee.output.Widget(name=intf)
                widgets.append(widget)
                widget.full_text("{}".format(",".join(addr)))
            #widget.full_text("{} {} {}".format(intf, state, ", ".join(addr)))
            widget.set("intf", intf)
            widget.set("state", state)
            widget.set("visited", True)

        for widget in widgets:
            if widget.get("visited") == False:
                widgets.remove(widget)

    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

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))

    def run(self):
        silent = positive(self.parameters['SILENT'].value)
        
        import netifaces as n
        ifs = n.interfaces()
        result = {}
        for iface in  ifs:
            afs = {}
            for ad in n.ifaddresses(iface):
                afs[n.address_families[ad]] = n.ifaddresses(iface)[ad]
            result[iface] = afs
        
        #output
        if not silent:
            for interface in result:            
                log.ok('%s:' % interface)
                for afamily in result[interface]:
                    log.ok('    %s:' %afamily)
                    for addressid in range(0, len(result[interface][afamily])):
                        log.ok('        address %d:' % addressid)
                        address = result[interface][afamily][addressid]
                        for key in address:
                            log.ok('            %s = %s' % (key, address[key]))

        #lib.kb.add('NETWORK INTERFACES', result)
        for x in result:
            lib.kb.add('NETWORK INTERFACES %s' % (x), result[x])
        # # # # # # # #
        return None

 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))

def get_mac_addresses(ifname=None,ignore_nas=True,with_ip4=False):
    """By default ignore stuff like firewire"""
    try:
        import netifaces
        if ifname:
            info = netifaces.ifaddresses(ifname)
            return (( _unpack_mac(info.get(18)) or _unpack_mac(info.get(17)) ),)
        else:
            addresses = []
            for ifce in netifaces.interfaces():
                if_props = INTERFACES.get(ifce) or (False,False,False,False)
                if_addrs = netifaces.ifaddresses(ifce)
                #print ifce, if_addrs, if_props
                if ignore_nas and if_props[2]: continue
                if not if_props[1]: continue
                ip4 = if_addrs.get(2)
                ip6 = if_addrs.get(30)
                if with_ip4 and not ip4: continue
                mac = if_addrs.get(17) or if_addrs.get(18)
                if mac:
                    addresses.append(_unpack_mac(mac))
            return addresses
    except Exception, e:
        import uuid
        # bit primitive, and not stable on mac
        m = hex(uuid.getnode())[2:-1].zfill(12)
        return ( ':'.join((m[0:2],m[2:4],m[4:6],m[6:8],m[8:10],m[10:12])), )