def validate_ipv4_address(cls, _, value): """ Ensures the :attr:`ip` address is valid. This checks to ensure that the value provided is: * not a hostmask * not link local (:rfc:`3927`) * not used for multicast (:rfc:`1112`) * not a netmask (:rfc:`4632`) * not reserved (:rfc:`6052`) * a private address (:rfc:`1918`) """ if value is None: return value try: address = IPAddress(value) except (AddrFormatError, ValueError) as e: raise ValueError( "%s is not a valid address format: %s" % (value, e)) if ALLOW_AGENT_LOOPBACK: loopback = lambda: False else: loopback = address.is_loopback if any([address.is_hostmask(), address.is_link_local(), loopback(), address.is_multicast(), address.is_netmask(), address.is_reserved()]): raise ValueError("%s is not a valid address type" % value) return value
def is_valid_address(address): ''' Validate whether the address provided is routable unicast address ''' addr = IPAddress(address) if addr.is_loopback() or addr.is_reserved() or addr.is_private()\ or addr.is_link_local() or addr.is_multicast(): return False return True
def call(self, url, context): if self.url_can_resolve(url): try: ip = yield self.resolver.get_host_by_name(url.domain) ip = IPAddress(ip) except Exception: # context["event"].target.respond( # u'[Error] Failed to handle URL: {}'.format( # url.to_string() # ) # ) self.plugin.logger.exception("Error while checking DNS") returnValue(STOP_HANDLING) return if ip.is_loopback() or ip.is_private() or ip.is_link_local() \ or ip.is_multicast(): self.plugin.logger.warn( "Prevented connection to private/internal address" ) returnValue(STOP_HANDLING) return headers = {} if url.domain in context["config"]["spoofing"]: user_agent = context["config"]["spoofing"][url.domain] if user_agent: headers["User-Agent"] = user_agent else: headers["User-Agent"] = context["config"].get( "default_user_agent", "Mozilla/5.0 (Windows NT 6.3; rv:36.0) Gecko/20100101 " "Firefox/36.0" ) domain_langs = context.get("config") \ .get("accept_language", {}) \ .get("domains", {}) if url.domain in domain_langs: headers["Accept-Language"] = domain_langs.get(url.domain) else: headers["Accept-Language"] = context.get("config") \ .get("accept_language", {}) \ .get("default", "en") session = self.get_session(url, context) session.get(unicode(url), headers=headers, stream=True, background_callback=self.background_callback) \ .addCallback(self.callback, url, context, session) \ .addErrback(self.errback, url, context, session) returnValue(STOP_HANDLING)
def local_addresses(): result = [] sp = subprocess.run(['/sbin/ifconfig'], capture_output=True, text=True) for line in sp.stdout.split('\n'): if line.find('\tinet') > -1: try: ip = IPAddress(line.split()[1].split('%')[0]) except AddrFormatError: ip = None if ip and not ip.is_loopback() and not ip.is_link_local(): result.append(ip) return result
def _getListenAddresses(self, port): """Return list of tuple (address, port) for the addresses the worker is listening on.""" addresses = get_all_interface_source_addresses() if addresses: return set((addr, port) for addr in addresses) # There are no non-loopback addresses, so return loopback # address as a fallback. loopback_addresses = set() for addr in get_all_interface_addresses(): ipaddr = IPAddress(addr) if ipaddr.is_link_local(): continue # Don't advertise link-local addresses. if ipaddr.is_loopback(): loopback_addresses.add((addr, port)) return loopback_addresses
def validate_gateway_ip(self): if self.gateway_ip is None or self.gateway_ip == "": return gateway_addr = IPAddress(self.gateway_ip) network = self.get_ipnetwork() if gateway_addr in network: # If the gateway is in the network, it is fine. return elif network.version == 6 and gateway_addr.is_link_local(): # If this is an IPv6 network and the gateway is in the link-local # network (fe80::/64 -- required to be configured by the spec), # then it is also valid. return else: # The gateway is not valid for the network. message = "Gateway IP must be within CIDR range." raise ValidationError({"gateway_ip": [message]})
def ip_check_routable(item): ip_addr = IPAddress(item) # This prevents netaddr allowing shortened ip addresses if not str(ip_addr) == item: raise AddrFormatError("IP Malformed {}".format(item)) # Check for reserved IP addresses if any([ ip_addr.is_multicast(), ip_addr.is_private(), ip_addr.is_loopback(), ip_addr.is_link_local(), ip_addr.is_reserved() ]): raise AddrFormatError("IP is reserved {}".format(item)) # Check to see if IP is IPv4 # elif ip_addr.version is not 4: # raise AddrFormatError("IP is not IPv4") return True
""" IPAddress from netaddr in Python Please Subscribe to Asim Code. YouTube Channel: Asim Code https://youtu.be/gMtBiNjgeKE """ from netaddr import IPAddress ip = IPAddress('192.168.56.1') print(ip.version) print(ip.bin) print(ip.bits()) print(ip.words) print(ip.is_unicast()) print(ip.is_link_local())
def callback(self, result, url, context, session): response = result[0] content = result[1] self.plugin.logger.trace( "Headers: {0}", list(response.headers) ) self.plugin.logger.trace("HTTP code: {0}", response.status_code) new_url = urlparse.urlparse(response.url) if self.url_can_resolve(url): try: ip = yield self.resolver.get_host_by_name(new_url.hostname) ip = IPAddress(ip) except Exception: # context["event"].target.respond( # u'[Error] Failed to handle URL: {}'.format( # url.to_string() # ) # ) self.plugin.logger.exception("Error while checking DNS") returnValue(STOP_HANDLING) return if ip.is_loopback() or ip.is_private() or ip.is_link_local() \ or ip.is_multicast(): self.plugin.logger.warn( "Prevented connection to private/internal address" ) returnValue(STOP_HANDLING) return if content is None: self.plugin.logger.debug("No content returned") return soup = BeautifulSoup(content) if soup.title and soup.title.text: title = soup.title.text.strip() title = re.sub("[\n\s]+", " ", title) title = to_unicode(title) title_limit = self.urls_plugin.config.get("max_title_length", 150) if len(title) > title_limit: title = title[:title_limit - 15] + u"... (truncated)" if response.status_code == requests.codes.ok: context["event"].target.respond( u'"{0}" at {1}'.format( title, new_url.hostname ) ) else: context["event"].target.respond( u'[HTTP {0}] "{1}" at {2}'.format( response.status_code, title, new_url.hostname ) ) else: if response.status_code != requests.codes.ok: context["event"].target.respond( u'HTTP Error {0}: "{1}" at {2}'.format( response.status_code, STATUS_CODES.get(response.status_code, "Unknown"), new_url.hostname ) ) else: self.plugin.logger.debug("No title") self.save_session(session)
def check_ip(dns_result: str) -> bool: addr = IPAddress(dns_result) if ((not addr.is_unicast()) or addr.is_private() or addr.is_loopback() or addr.is_link_local()): return False return True