def __new__(cls, addr, s=None): if s is None: host, port = addr for af_type, cls in connector_registry.iteritems(): try : socket.inet_pton(af_type, host) break except socket.error: pass else: raise ValueError("Unknown type of host", host) self = object.__new__(cls) self.addr = cls._normAddress(addr) if s is None: s = socket.socket(af_type, socket.SOCK_STREAM) else: self.is_server = True self.is_closed = False self.socket = s self.socket_fd = s.fileno() # always use non-blocking sockets s.setblocking(0) # disable Nagle algorithm to reduce latency s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) self.queued = [] return self
def validate_ipv6(ip_text): try: socket.inet_pton(socket.AF_INET6, ip_text) except socket.error: return False else: return True
def join_network(self, seed_peers=None, callback=lambda msg: None): if seed_peers is None: seed_peers = [] self.log.info('Joining network') known_peers = [] # Connect up through seed servers for idx, seed in enumerate(seed_peers): try: socket.inet_pton(socket.AF_INET6, seed) seed_peers[idx] = "tcp://[%s]:12345" % seed except (socket.error, ValueError): seed_peers[idx] = "tcp://%s:12345" % seed # Connect to persisted peers db_peers = self.get_past_peers() known_peers = list(set(seed_peers)) + list(set(db_peers)) self.connect_to_peers(known_peers) # TODO: This needs rethinking. Normally we can search for ourselves # but because we are not connected to them quick enough this # will always fail. Need @gubatron to review # Populate routing table by searching for self # if len(known_peers) > 0: # self.search_for_my_node() if callback is not None: callback('Joined')
def convdata(self, dtype, data): if dtype == "4": if type(data) != str: raise error("IPv4 address must be a string") if len(data) == 4: d = data else: d = socket.inet_pton(socket.AF_INET, data) if dtype == "6": if type(data) != str: raise error("IPv6 address must be a string") if len(data) == 16 and data.find(":") == -1: d = data else: d = socket.inet_pton(socket.AF_INET6, data) if dtype == "d": if type(data) == str: d = dn.fromstring(data) elif isinstance(data, dn.domainname): d = data else: raise error("Domain name must be either proper or string") if dtype == "s": d = str(data) if dtype == "i": d = int(data) return d
def prepareBaseReply(self, request): request.setETag("RTSP/1.0") request.setResponseCode(200) request.setHeader("cseq", request.received_headers["cseq"]) request.setHeader("audio-jack-status", "connected; type=analog") if "apple-challenge" in request.received_headers: challenge = request.received_headers["apple-challenge"] if challenge[-2:] != "==": challenge += "==" data = base64.b64decode(challenge) host = request.getHost().host if (host.split(".")) == 4: # ipv4 data += socket.inet_pton(socket.AF_INET, host) elif host[:7] == "::ffff:": data += socket.inet_pton(socket.AF_INET, host[7:]) else: data += socket.inet_pton(socket.AF_INET6, host.split("%")[0]) hwaddr = self.info.deviceid for i in range (0, 12, 2): data += chr(int(hwaddr[i:i+2], 16)) data = data.ljust(32, '\0') #self.dump(data) key = RSA.load_key_string(AIRPORT_PRIVATE_KEY) signature = base64.b64encode(key.private_encrypt(data, RSA.pkcs1_padding)) if signature[-2:] == "==": signature = signature[:-2] request.setHeader("apple-response", signature)
def _ipv4(s): try: socket.inet_pton(socket.AF_INET, s) except socket.error: if not re.match(RE_IPV4, s): return False return True
def __init__(self, market_id, my_ip, my_port, my_guid, nickname=None): self.peers = {} self.callbacks = defaultdict(list) self.timeouts = [] self.port = my_port self.ip = my_ip self.guid = my_guid self.market_id = market_id self.nickname = nickname self.handler = None # Create one ZeroMQ context to be reused and reduce overhead self.ctx = zmq.Context() try: socket.inet_pton(socket.AF_INET6, my_ip) my_uri = 'tcp://[%s]:%s' % (self.ip, self.port) except (socket.error, ValueError): my_uri = 'tcp://%s:%s' % (self.ip, self.port) self.uri = my_uri self.log = logging.getLogger( '[%s] %s' % (market_id, self.__class__.__name__) )
def _in6_getifaddr(ifname): """ Returns a list of IPv6 addresses configured on the interface ifname. """ # Get the output of ifconfig try: f = os.popen("%s %s" % (conf.prog.ifconfig, ifname)) except OSError as msg: log_interactive.warning("Failed to execute ifconfig.") return [] # Iterate over lines and extract IPv6 addresses ret = [] for line in f: if "inet6" in line: addr = line.rstrip().split(None, 2)[1] # The second element is the IPv6 address else: continue if '%' in line: # Remove the interface identifier if present addr = addr.split("%", 1)[0] # Check if it is a valid IPv6 address try: socket.inet_pton(socket.AF_INET6, addr) except: continue # Get the scope and keep the address scope = in6_getscope(addr) ret.append((addr, scope, ifname)) return ret
def is_ipv6(addr): """Checks if a given address is an IPv6 address.""" try: socket.inet_pton(socket.AF_INET6, addr) return True except socket.error: return False
def _isIPv4Address(address): try: socket.inet_pton(socket.AF_INET, address) except socket.error: return False else: return True
def join_network(self, seed_peers=[], callback=lambda msg: None): self.log.info('Joining network') known_peers = [] # Connect up through seed servers for idx, seed in enumerate(seed_peers): try: socket.inet_pton(socket.AF_INET6, seed) seed_peers[idx] = "tcp://[%s]:12345" % seed except socket.error: seed_peers[idx] = "tcp://%s:12345" % seed # Connect to persisted peers db_peers = self.get_past_peers() known_peers = list(set(seed_peers)) + list(set(db_peers)) print 'known_peers', known_peers self.connect_to_peers(known_peers) # Populate routing table by searching for self if len(known_peers) > 0: self.search_for_my_node() if callback is not None: callback('Joined')
def isIPV6(self, string_ip): ipv6 = True try: socket.inet_pton(socket.AF_INET6, string_ip) except: ipv6 = False return ipv6
def is_ip(value): """Determine if the given string is an IP address. Python 2 on Windows doesn't provide ``inet_pton``, so this only checks IPv4 addresses in that environment. :param value: value to check :type value: str :return: True if string is an IP address :rtype: bool """ if PY2 and os.name == 'nt': try: socket.inet_aton(value) return True except socket.error: return False for family in (socket.AF_INET, socket.AF_INET6): try: socket.inet_pton(family, value) except socket.error: pass else: return True return False
def get_packed_host(self): """Returns a BEP_0005 'packed' representation of the addr.""" try: result = socket.inet_pton(socket.AF_INET, self.host) except (ValueError, socket.error): result = socket.inet_pton(socket.AF_INET6, self.host) return buffer(result)
def query_nat(self, family, proto, src_ip, src_port, dst_ip, dst_port): [proto, family, src_port, dst_port] = [ int(v) for v in [proto, family, src_port, dst_port]] packed_src_ip = socket.inet_pton(family, src_ip) packed_dst_ip = socket.inet_pton(family, dst_ip) assert len(packed_src_ip) == len(packed_dst_ip) length = len(packed_src_ip) pnl = self.pfioc_natlook() pnl.proto = proto pnl.direction = self.PF_OUT pnl.af = family memmove(addressof(pnl.saddr), packed_src_ip, length) memmove(addressof(pnl.daddr), packed_dst_ip, length) self._add_natlook_ports(pnl, src_port, dst_port) ioctl(pf_get_dev(), self.DIOCNATLOOK, (c_char * sizeof(pnl)).from_address(addressof(pnl))) ip = socket.inet_ntop( pnl.af, (c_char * length).from_address(addressof(pnl.rdaddr)).raw) port = socket.ntohs(self._get_natlook_port(pnl.rdxport)) return (ip, port)
def get_host_addrs(self, host, port=0): # Try IPv6 try: socket.inet_pton(socket.AF_INET6, host) return [host] except socket.error: pass # Try IPv4 try: socket.inet_pton(socket.AF_INET, host) return [host] except socket.error: pass # So it's a hostname, try to resolve try: info = socket.getaddrinfo(host, port, 0, 0, 0, socket.AI_CANONNAME) ips = [] for family, socktype, proto, canonname, sockaddr in info: ips.append(sockaddr[0]) return ips except (socket.error, IndexError): pass # All failed return []
def add_addr(cmd, _type, addr): if addr is None: return host = None from socket import inet_pton,AF_INET,AF_INET6 try: inet_pton(AF_INET, addr['uri']['host']) host = addr['uri']['host'] except: pass try: inet_pton(AF_INET6, addr['uri']['host']) host = addr['uri']['host'] except: pass cursor.execute("""INSERT INTO dionaea.sip_addrs (sip_command, sip_addr_type, sip_addr_display_name, sip_addr_uri_scheme, sip_addr_uri_user, sip_addr_uri_password, sip_addr_uri_hostname, sip_addr_uri_host, sip_addr_uri_port) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s)""", ( cmd, _type, addr['display_name'], addr['uri']['scheme'], addr['uri']['user'], addr['uri']['password'], addr['uri']['host'], host, addr['uri']['port'] ))
def get_all_names(self): """Returns all names found in the Nginx Configuration. :returns: All ServerNames, ServerAliases, and reverse DNS entries for virtual host addresses :rtype: set """ all_names = set() # type: Set[str] for vhost in self.parser.get_vhosts(): all_names.update(vhost.names) for addr in vhost.addrs: host = addr.get_addr() if common.hostname_regex.match(host): # If it's a hostname, add it to the names. all_names.add(host) elif not common.private_ips_regex.match(host): # If it isn't a private IP, do a reverse DNS lookup try: if addr.ipv6: host = addr.get_ipv6_exploded() socket.inet_pton(socket.AF_INET6, host) else: socket.inet_pton(socket.AF_INET, host) all_names.add(socket.gethostbyaddr(host)[0]) except (socket.error, socket.herror, socket.timeout): continue return util.get_filtered_names(all_names)
def check_ipv6(n): """ Returns true if n is IPv6 address, false otherwise. """ try: socket.inet_pton(socket.AF_INET6, n) return True except: return False
def ipv6(value): '''Validate an IPv6 address''' try: socket.inet_pton(socket.AF_INET6, value) return value except socket.error: raise ValueError('{0} is not a valid ipv4 address'.format(value))
def is_local_interface(host): is_ipv6 = False if ':' in host: try: if host.find('[', 0, 2) != -1: last_bracket_position = host.rfind(']') last_colon_position = host.rfind(':') if last_colon_position > last_bracket_position: host = host.rsplit(':', 1)[0] host = host.strip('[]') socket.inet_pton(socket.AF_INET6, host) is_ipv6 = True except socket.error: host = host.split(':',1)[0] try: if is_ipv6: sock = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM) else: sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.connect( (host, 4242) ) local_ip = sock.getsockname()[0] sock.close() except: log.exception("Failed to open socket with %s" % host) raise if local_ip == host: return True return False
def valid_ipv6(ip): """Returns True if the given string is a valid IPv6 address.""" try: socket.inet_pton(socket.AF_INET6, ip) except socket.error: # not a valid ip return False return True
def validate(self, value): valid = True try: socket.inet_pton(self.family, value) except: valid = False return valid
def setup(hass, config): """Set up Zeroconf and make Home Assistant discoverable.""" from zeroconf import Zeroconf, ServiceInfo zeroconf = Zeroconf() zeroconf_name = '{}.{}'.format(hass.config.location_name, ZEROCONF_TYPE) requires_api_password = hass.config.api.api_password is not None params = { 'version': __version__, 'base_url': hass.config.api.base_url, 'requires_api_password': requires_api_password, } host_ip = util.get_local_ip() try: host_ip_pton = socket.inet_pton(socket.AF_INET, host_ip) except socket.error: host_ip_pton = socket.inet_pton(socket.AF_INET6, host_ip) info = ServiceInfo(ZEROCONF_TYPE, zeroconf_name, host_ip_pton, hass.http.server_port, 0, 0, params) zeroconf.register_service(info) def stop_zeroconf(event): """Stop Zeroconf.""" zeroconf.unregister_service(info) zeroconf.close() hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, stop_zeroconf) return True
def is_valid_ipv4(string): '''' >>> is_valid_ipv4('127.0.0.1') True >>> is_valid_ipv4('192.168.1.1') True >>> is_valid_ipv4('255.255.255') False ''' # http://stackoverflow.com/questions/319279/ # how-to-validate-ip-address-in-python import socket try: socket.inet_pton(socket.AF_INET, string) except AttributeError: # no inet_pton here, sorry try: socket.inet_aton(string) except socket.error: return False return string.count('.') == 3 except socket.error: # not a valid address return False return True
def cidr_to_list(self, string): # references: # http://boubakr92.wordpress.com/2012/12/20/convert-cidr-into-ip-range-with-python/ # http://stackoverflow.com/questions/8338655/how-to-get-list-of-ip-addresses # parse address and cidr (addrString, cidrString) = string.split('/') # split address into octets and convert cidr to int addr = addrString.split('.') cidr = int(cidrString) # initialize the netmask and calculate based on cidr mask mask = [0, 0, 0, 0] for i in range(cidr): mask[i/8] = mask[i/8] + (1 << (7 - i % 8)) # initialize net and binary and netmask with addr to get network net = [] for i in range(4): net.append(int(addr[i]) & mask[i]) # duplicate net into broad array, gather host bits, and generate broadcast broad = list(net) brange = 32 - cidr for i in range(brange): broad[3 - i/8] = broad[3 - i/8] + (1 << (i % 8)) # print information, mapping integer lists to strings for easy printing #mask = '.'.join(map(str, mask)) net = '.'.join(map(str, net)) broad = '.'.join(map(str, broad)) ips = [] f = struct.unpack('!I',socket.inet_pton(socket.AF_INET,net))[0] l = struct.unpack('!I',socket.inet_pton(socket.AF_INET,broad))[0] while f <= l: ips.append(socket.inet_ntop(socket.AF_INET,struct.pack('!I',f))) f = f + 1 return ips
def is_ip6(self): from socket import inet_pton, AF_INET6, error try: inet_pton(AF_INET6, self.host) return True except error: return False
def validip6addr(addr): try: socket.inet_pton(socket.AF_INET6, addr) except (socket.error, AttributeError): return False print "Invalid Ipv6 Address" return True
def is_valid_ipv6_address(self, address): if address == '': return True try: socket.inet_pton(socket.AF_INET6, address) except socket.error, AttributeError: return False
def build_dst_address(self, host, port): family_to_byte = {socket.AF_INET: c.SOCKS5_ATYP_IPv4, socket.AF_INET6: c.SOCKS5_ATYP_IPv6} port_bytes = struct.pack('>H', port) # if the given destination address is an IP address, we will # use the IP address request even if remote resolving was specified. for family in (socket.AF_INET, socket.AF_INET6): try: host_bytes = socket.inet_pton(family, host) req = [family_to_byte[family], host_bytes, port_bytes] return req, (host, port) except socket.error: pass # it's not an IP number, so it's probably a DNS name. if self._remote_resolve: host_bytes = host.encode('idna') req = [c.SOCKS5_ATYP_DOMAIN, chr(len(host_bytes)).encode(), host_bytes, port_bytes] else: family, host_bytes = yield from self._get_dst_addr() host_bytes = socket.inet_pton(family, host_bytes) req = [family_to_byte[family], host_bytes, port_bytes] host = socket.inet_ntop(family, host_bytes) return req, (host, port)
def addr2bin(string): """ Convert a string IPv4/IPv6 address into an unsigned integer. """ return struct.unpack("!L", socket.inet_pton(DNSUtils.IP_TYPE, string))[0]
def ip4n(self): """ IPv4 address of remote host - raw, suitable as API parameter.""" return socket.inet_pton(socket.AF_INET, self._ip4)
def EncodeIP(ip): return socket.inet_pton(socket.AF_INET, ip)
def ipv4_from_string(ipv4_string): data = socket.inet_pton(socket.AF_INET, ipv4_string) ipv4_n = struct.unpack('I', data) ipv4 = socket.ntohl(ipv4_n[0]) return ipv4
class KZorpTestCaseServices(KZorpComm): services = [ (kznl.KZorpAddProxyServiceMessage, { 'name': "test-proxy" }), (kznl.KZorpAddForwardServiceMessage, { 'name': "test3", 'dst_family': socket.AF_INET, 'dst_ip': socket.inet_pton(socket.AF_INET, '1.2.3.4'), 'dst_port': 1 }), (kznl.KZorpAddForwardServiceMessage, { 'name': "test6", 'dst_family': socket.AF_INET, 'dst_ip': socket.inet_pton(socket.AF_INET, '1.2.3.4'), 'dst_port': 1 }), (kznl.KZorpAddProxyServiceMessage, { 'name': 'test5', 'count': 303 }), (kznl.KZorpAddDenyServiceMessage, { 'name': 'test-deny', 'logging': True, 'count': 33, 'ipv4_settings': kznl.DenyIPv4.DROP, 'ipv6_settings': kznl.DenyIPv6.DROP }), ] def check_svc_num(self, num_svc): _dumped_zones = [] self.send_message(kznl.KZorpGetServiceMessage(None), message_handler=_dumped_zones.append, dump=True) self.assertEqual(num_svc, len(_dumped_zones)) def check_send(self, message, return_value): self.start_transaction() r = self.send_message(message, assert_on_error=False) self.end_transaction() self.assertEqual(return_value, r) def newSetUp(self): self.start_transaction() for service in self.services: self.send_message(service[0](**service[1])) self.end_transaction() def tearDown(self): self.flush_all() def test_get_service(self): def check_get_reply(self, service, reply): for (name, value) in service[1].items(): self.assertEqual(getattr(reply, name), value) self.newSetUp() self.check_svc_num(len(self.services)) self.assertEqual( -2, self.send_message(kznl.KZorpGetServiceMessage("nonexistent"), assert_on_error=False)) for service in self.services: self.send_message( kznl.KZorpGetServiceMessage(service[1].get('name')), message_handler=partial(check_get_reply, self, service)) def test_add_service_duplicated(self): self.newSetUp() service_cnt = len(self.services) #duplicated entry check: the matching service was in the same transaction self.start_transaction() self.send_message(kznl.KZorpAddProxyServiceMessage("dupe1")) res = self.send_message(kznl.KZorpAddProxyServiceMessage("dupe1"), assert_on_error=False) self.end_transaction() self.assertEqual(-errno.EEXIST, res) service_cnt += 1 self.check_svc_num(service_cnt) #duplicated entry check: the matching service was already existing self.check_send(kznl.KZorpAddProxyServiceMessage("dupe1"), -errno.EEXIST) self.check_svc_num(service_cnt) def test_add_service_invalid(self): class KZorpAddInvalidServiceMessage(kznl.KZorpAddServiceMessage): type_string = "Invalid" def __init__(self, name): super(KZorpAddInvalidServiceMessage, self).__init__(name, kznl.KZ_SVC_PROXY + 100, 0, 0) self._build_payload() self.newSetUp() service_cnt = len(self.services) #invalid service type self.check_send(KZorpAddInvalidServiceMessage("invalid_service_type"), -errno.EINVAL) self.check_svc_num(service_cnt) def test_add_service(self): self.newSetUp() service_cnt = len(self.services) #outside of transaction self.assertEqual( -errno.ENOENT, self.send_message(self.services[0][0](**self.services[0][1]), assert_on_error=False)) self.check_svc_num(service_cnt) def test_add_service_flags(self): self.newSetUp() service_cnt = len(self.services) for i in range(2 * kznl.KZF_SVC_LOGGING): self.check_send(kznl.KZorpAddProxyServiceMessage("flag-%d" % i, i), 0) service_cnt += 2 * kznl.KZF_SVC_LOGGING self.check_svc_num(service_cnt) # using undefined flags self.start_transaction() res = self.send_message(kznl.KZorpAddProxyServiceMessage( "flag-invalid", flags=0xfffffffc), assert_on_error=False) self.end_transaction() self.assertNotEqual(0, res) def test_add_service_nontransparent(self): self.newSetUp() service_cnt = len(self.services) self.check_send( kznl.KZorpAddForwardServiceMessage("test-nontransparent-router", flags=0, count=0, dst_family=socket.AF_INET, dst_ip=socket.inet_pton( socket.AF_INET, '1.2.3.4'), dst_port=10010), 0) service_cnt += 1 self.check_svc_num(service_cnt) self.check_send( kznl.KZorpAddForwardServiceMessage("test-nontransparent-norouter", flags=0, count=0), -errno.EINVAL) self.check_svc_num(service_cnt) def _test_add_service_nat(self, nat_message_class): service_cnt = len(self.services) #adding a nat rule to a service added in the same transaction self.start_transaction() self.send_message( kznl.KZorpAddForwardServiceMessage('test-nat', flags=kznl.KZF_SVC_TRANSPARENT)) self.send_message( nat_message_class('test-nat', nat_src=(kznl.KZ_SVC_NAT_MAP_IPS + kznl.KZ_SVC_NAT_MAP_PROTO_SPECIFIC, 12345688, 12345689, 1024, 1025), nat_map=(kznl.KZ_SVC_NAT_MAP_IPS + kznl.KZ_SVC_NAT_MAP_PROTO_SPECIFIC, 12345688, 12345689, 1024, 1025))) self.end_transaction() service_cnt += 2 self.check_svc_num(service_cnt) def test_add_service_nat_dst(self): self.newSetUp() self._test_add_service_nat( kznl.KZorpAddServiceDestinationNATMappingMessage) def test_add_service_nat_src(self): self.newSetUp() self._test_add_service_nat(kznl.KZorpAddServiceSourceNATMappingMessage) def test_add_deny_service(self): response = [] m = kznl.KZorpAddDenyServiceMessage("denyservice", False, 0, kznl.DenyIPv4.DROP, kznl.DenyIPv6.DROP) self.start_transaction() self.send_message(m) self.end_transaction() self.start_transaction() self.send_message(kznl.KZorpGetServiceMessage("denyservice"), message_handler=response.append, dump=True) self.end_transaction() self.assertEqual(1, len(response))
def is_valid_ipv6_address(addr): try: socket.inet_pton(socket.AF_INET6, addr) except socket.error: return False return True
def _NlAttrIPAddress(self, nla_type, family, address): return self._NlAttr(nla_type, socket.inet_pton(family, address))
def storeKeyValue(self, nodes, key, value, originalPublisherID, age): self.log.debug('Store Key Value: (%s, %s %s)' % (nodes, key, type(value))) try: value_json = json.loads(value) # Add Notary GUID to index if 'notary_index_add' in value_json: existing_index = self.dataStore[key] if existing_index is not None: if not value_json['notary_index_add'] in existing_index['notaries']: existing_index['notaries'].append(value_json['notary_index_add']) value = existing_index else: value = {'notaries': [value_json['notary_index_add']]} self.log.info('Notaries: %s' % existing_index) if 'notary_index_remove' in value_json: existing_index = self.dataStore[key] if existing_index is not None: if value_json['notary_index_remove'] in existing_index['notaries']: existing_index['notaries'].remove(value_json['notary_index_remove']) value = existing_index else: return else: return # Add listing to keyword index if 'keyword_index_add' in value_json: existing_index = self.dataStore[key] if existing_index is not None: if not value_json['keyword_index_add'] in existing_index['listings']: existing_index['listings'].append(value_json['keyword_index_add']) value = existing_index else: value = {'listings': [value_json['keyword_index_add']]} self.log.info('Keyword Index: %s' % value) if 'keyword_index_remove' in value_json: existing_index = self.dataStore[key] if existing_index is not None: if value_json['keyword_index_remove'] in existing_index['listings']: existing_index['listings'].remove(value_json['keyword_index_remove']) value = existing_index else: return else: # Not in keyword index anyways return except Exception as e: self.log.debug('Value is not a JSON array: %s' % e) now = int(time.time()) originallyPublished = now - age # Store it in your own node self.dataStore.setItem(key, value, now, originallyPublished, originalPublisherID, market_id=self.market_id) for node in nodes: self.log.debug('Sending data to store in DHT: %s' % str(node)) try: socket.inet_pton(socket.AF_INET6, node[0]) uri = 'tcp://[%s]:%s' % (node[0], node[1]) except (socket.error, ValueError): uri = 'tcp://%s:%s' % (node[0], node[1]) guid = node[2] peer = self.routingTable.getContact(guid) if guid == self.transport.guid: break if not peer: peer = self.transport.get_crypto_peer(guid, uri) peer.start_handshake() peer.send(proto_store(key, value, originalPublisherID, age))
def validate_ip_v6_address(address): try: socket.inet_pton(socket.AF_INET6, address) except socket.error: return False return True
def to_net_addr(addr): return socket.inet_pton(socket.AF_INET6, addr)
def inet_pton(afam, text): return socket.inet_pton(afam, text)
def test_delete_tunnel_ip_flow_dl(self): dest_ip = IPAddress( version=IPAddress.IPV4, address=socket.inet_pton(socket.AF_INET, "192.168.128.12"), ) src_ip = IPAddress( version=IPAddress.IPV4, address=socket.inet_pton(socket.AF_INET, "192.168.129.64"), ) ip_flow_dl = IPFlowDL( set_params=71, tcp_dst_port=0, tcp_src_port=5002, udp_dst_port=0, udp_src_port=0, ip_proto=6, dest_ip=dest_ip, src_ip=src_ip, precedence=65530, ) seid1 = 5000 ue_ip_addr = "192.168.128.30" self.classifier_controller.gtp_handler( 1, 65525, 1, 100000, IPAddress(version=IPAddress.IPV4, address=ue_ip_addr.encode('utf-8')), self.EnodeB_IP, seid1, ip_flow_dl=ip_flow_dl, ) dest_ip = IPAddress( version=IPAddress.IPV4, address=socket.inet_pton(socket.AF_INET, "192.168.128.111"), ) src_ip = IPAddress( version=IPAddress.IPV4, address=socket.inet_pton(socket.AF_INET, "192.168.129.4"), ) ip_flow_dl = IPFlowDL( set_params=70, tcp_dst_port=0, tcp_src_port=0, udp_dst_port=80, udp_src_port=5060, ip_proto=17, dest_ip=dest_ip, src_ip=src_ip, precedence=65525, ) seid2 = 5001 ue_ip_addr = "192.168.128.31" self.classifier_controller.gtp_handler( 1, 65525, 2, 100001, IPAddress(version=IPAddress.IPV4, address=ue_ip_addr.encode('utf-8')), self.EnodeB_IP, seid2, ip_flow_dl=ip_flow_dl, ) snapshot_verifier = SnapshotVerifier( self, self.BRIDGE, self.service_manager, ) with snapshot_verifier: pass
def __init__(self, server_address, xml_file, multicast=False, starting_mid=None, cache=False, sock=None): """ Initialize the Reverse Proxy. :param server_address: Server address for incoming connections :param xml_file: the xml file that describe remote servers :param multicast: if the ip is a multicast address :param starting_mid: used for testing purposes :param cache: if a cache must be used :param sock: if a socket has been created externally, it can be used directly """ self.stopped = threading.Event() self.stopped.clear() self.to_be_stopped = [] self.purge = threading.Thread(target=self.purge) self.purge.start() self._messageLayer = MessageLayer(starting_mid) self._blockLayer = BlockLayer() self._observeLayer = ObserveLayer() self._forwardLayer = ForwardLayer(self) self.resourceLayer = ResourceLayer(self) self.cache_enable = cache if self.cache_enable: self._cacheLayer = CacheLayer(defines.REVERSE_PROXY) else: self._cacheLayer = None # Resource directory root = Resource('root', self, visible=False, observable=False, allow_children=True) root.path = '/' self.root = Tree() self.root["/"] = root self._serializer = None self.server_address = server_address self.multicast = multicast self.file_xml = xml_file self._mapping = {} addrinfo = socket.getaddrinfo(self.server_address[0], None)[0] if sock is not None: # Use given socket, could be a DTLS socket self._socket = sock self.parse_config() elif self.multicast: # pragma: no cover # Create a socket # self._socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_TTL, 255) # self._socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_LOOP, 1) # Join group if addrinfo[0] == socket.AF_INET: # IPv4 self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) # Allow multiple copies of this program on one machine # (not strictly needed) self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._socket.bind(('', self.server_address[1])) mreq = struct.pack("4sl", socket.inet_aton(defines.ALL_COAP_NODES), socket.INADDR_ANY) self._socket.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq) else: # Bugfix for Python 3.6 for Windows ... missing IPPROTO_IPV6 constant if not hasattr(socket, 'IPPROTO_IPV6'): socket.IPPROTO_IPV6 = 41 self._socket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM, socket.IPPROTO_UDP) # Allow multiple copies of this program on one machine # (not strictly needed) self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._socket.bind(('', self.server_address[1])) addrinfo_multicast = socket.getaddrinfo( defines.ALL_COAP_NODES_IPV6, 5683)[0] group_bin = socket.inet_pton(socket.AF_INET6, addrinfo_multicast[4][0]) mreq = group_bin + struct.pack('@I', 0) self._socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_JOIN_GROUP, mreq) else: if addrinfo[0] == socket.AF_INET: # IPv4 self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) else: self._socket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM) self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._socket.bind(self.server_address) self.parse_config()
def __init__(self, server_address, multicast=False, starting_mid=None, sock=None, cb_ignore_listen_exception=None): """ Initialize the server. :param server_address: Server address for incoming connections :param multicast: if the ip is a multicast address :param starting_mid: used for testing purposes :param sock: if a socket has been created externally, it can be used directly :param cb_ignore_listen_exception: Callback function to handle exception raised during the socket listen operation """ self.stopped = threading.Event() self.stopped.clear() self.to_be_stopped = [] self.purge = threading.Thread(target=self.purge) self.purge.start() self._messageLayer = MessageLayer(starting_mid) self._blockLayer = BlockLayer() self._observeLayer = ObserveLayer() self._requestLayer = RequestLayer(self) self.resourceLayer = ResourceLayer(self) # Resource directory root = Resource('root', self, visible=False, observable=False, allow_children=False) root.path = '/' self.root = Tree() self.root["/"] = root self._serializer = None self.server_address = server_address self.multicast = multicast self._cb_ignore_listen_exception = cb_ignore_listen_exception addrinfo = socket.getaddrinfo(self.server_address[0], None)[0] if sock is not None: # Use given socket, could be a DTLS socket self._socket = sock elif self.multicast: # pragma: no cover # Create a socket # self._socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_TTL, 255) # self._socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_LOOP, 1) # Join group if addrinfo[0] == socket.AF_INET: # IPv4 self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) # Allow multiple copies of this program on one machine # (not strictly needed) self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._socket.bind( (defines.ALL_COAP_NODES, self.server_address[1])) mreq = struct.pack("4sl", socket.inet_aton(defines.ALL_COAP_NODES), socket.INADDR_ANY) self._socket.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq) self._unicast_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._unicast_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._unicast_socket.bind(self.server_address) else: self._socket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM, socket.IPPROTO_UDP) # Allow multiple copies of this program on one machine # (not strictly needed) self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._socket.bind( (defines.ALL_COAP_NODES_IPV6, self.server_address[1])) addrinfo_multicast = socket.getaddrinfo( defines.ALL_COAP_NODES_IPV6, 5683)[0] group_bin = socket.inet_pton(socket.AF_INET6, addrinfo_multicast[4][0]) mreq = group_bin + struct.pack('@I', 0) self._socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_JOIN_GROUP, mreq) self._unicast_socket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM) self._unicast_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._unicast_socket.bind(self.server_address) else: if addrinfo[0] == socket.AF_INET: # IPv4 self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) else: self._socket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM) self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._socket.bind(self.server_address)
def setUpClass(cls): super(TestVxlanGpe, cls).setUpClass() try: cls.dport = 4790 cls.flags = 0x0c # Create 2 pg interfaces. cls.create_pg_interfaces(range(4)) for pg in cls.pg_interfaces: pg.admin_up() # Configure IPv4 addresses on VPP pg0. cls.pg0.config_ip4() # Resolve MAC address for VPP's IP address on pg0. cls.pg0.resolve_arp() # Our Multicast address cls.mcast_ip4 = '239.1.1.1' cls.mcast_ip4n = socket.inet_pton(socket.AF_INET, cls.mcast_ip4) iplong = atol(cls.mcast_ip4) cls.mcast_mac = "01:00:5e:%02x:%02x:%02x" % ( (iplong >> 16) & 0x7F, (iplong >> 8) & 0xFF, iplong & 0xFF) # Create VXLAN-GPE VTEP on VPP pg0, and put vxlan_gpe_tunnel0 # and pg1 into BD. cls.single_tunnel_bd = 11 r = cls.vapi.vxlan_gpe_add_del_tunnel(src_addr=cls.pg0.local_ip4n, dst_addr=cls.pg0.remote_ip4n, vni=cls.single_tunnel_bd) cls.vapi.sw_interface_set_l2_bridge(rx_sw_if_index=r.sw_if_index, bd_id=cls.single_tunnel_bd) cls.vapi.sw_interface_set_l2_bridge( rx_sw_if_index=cls.pg1.sw_if_index, bd_id=cls.single_tunnel_bd) # Setup vni 2 to test multicast flooding cls.n_ucast_tunnels = 10 cls.mcast_flood_bd = 12 cls.create_vxlan_gpe_flood_test_bd(cls.mcast_flood_bd, cls.n_ucast_tunnels) r = cls.vapi.vxlan_gpe_add_del_tunnel(src_addr=cls.pg0.local_ip4n, dst_addr=cls.mcast_ip4n, mcast_sw_if_index=1, vni=cls.mcast_flood_bd) cls.vapi.sw_interface_set_l2_bridge(rx_sw_if_index=r.sw_if_index, bd_id=cls.mcast_flood_bd) cls.vapi.sw_interface_set_l2_bridge( rx_sw_if_index=cls.pg2.sw_if_index, bd_id=cls.mcast_flood_bd) # Add and delete mcast tunnels to check stability cls.add_shared_mcast_dst_load() cls.add_mcast_tunnels_load() cls.del_shared_mcast_dst_load() cls.del_mcast_tunnels_load() # Setup vni 3 to test unicast flooding cls.ucast_flood_bd = 13 cls.create_vxlan_gpe_flood_test_bd(cls.ucast_flood_bd, cls.n_ucast_tunnels) cls.vapi.sw_interface_set_l2_bridge( rx_sw_if_index=cls.pg3.sw_if_index, bd_id=cls.ucast_flood_bd) except Exception: super(TestVxlanGpe, cls).tearDownClass() raise
def _handle_stage_addr(self, data): addr, port = self._client_address if self._is_local: cmd = common.ord(data[1]) if cmd == CMD_UDP_ASSOCIATE: logging.debug('U[%d] UDP associate' % self._config['server_port']) if self._local_sock.family == socket.AF_INET6: header = b'\x05\x00\x00\x04' else: header = b'\x05\x00\x00\x01' addr_to_send = socket.inet_pton(self._local_sock.family, addr) port_to_send = struct.pack('>H', port) self._write_to_sock(header + addr_to_send + port_to_send, self._local_sock) self._stage = STAGE_UDP_ASSOC # just wait for the client to disconnect return elif cmd == CMD_CONNECT: # just trim VER CMD RSV data = data[3:] else: logging.error('U[%d] Unknown command %d', self._config['server_port'], cmd) self.destroy() return header_result = parse_header(data) if header_result is None: raise Exception('TCP can not parse header') addrtype, remote_addr, remote_port, header_length = header_result if self._config['firewall_ports'] and self._config[ 'server_port'] not in self._config['firewall_trusted']: # Firewall enabled if self._config[ 'firewall_mode'] == 'blacklist' and remote_port in self._config[ 'firewall_ports']: firewall_blocked = True elif self._config[ 'firewall_mode'] == 'whitelist' and remote_port not in self._config[ 'firewall_ports']: firewall_blocked = True else: firewall_blocked = False else: firewall_blocked = False if firewall_blocked: logging.warning('U[%d] TCP PORT BANNED: RP[%d] A[%s-->%s]' % (self._config['server_port'], remote_port, addr, common.to_str(remote_addr))) return else: logging.info('U[%d] TCP CONN: RP[%d] A[%s-->%s]' % (self._config['server_port'], remote_port, addr, common.to_str(remote_addr))) self._remote_address = (common.to_str(remote_addr), remote_port) # pause reading self._update_stream(STREAM_UP, WAIT_STATUS_WRITING) self._stage = STAGE_DNS if self._is_local: # forward address to remote self._write_to_sock((b'\x05\x00\x00\x01' b'\x00\x00\x00\x00\x10\x10'), self._local_sock) data_to_send = self._cryptor.encrypt(data) self._data_to_write_to_remote.append(data_to_send) # notice here may go into _handle_dns_resolved directly self._dns_resolver.resolve(self._chosen_server[0], self._handle_dns_resolved) else: if self._ota_enable_session: data = data[header_length:] self._ota_chunk_data(data, self._data_to_write_to_remote.append) elif len(data) > header_length: self._data_to_write_to_remote.append(data[header_length:]) # notice here may go into _handle_dns_resolved directly self._dns_resolver.resolve(remote_addr, self._handle_dns_resolved)
class NAT46(AbstractNAT): """ <class maturity="stable"> <summary> Class that performs translation from IPv4 to IPv6 addresses (NAT46) </summary> <description> NAT46 embeds and IPv4 address into a specific portion of the IPv6 address according to the NAT46 specification as described in RFC6052 (http://tools.ietf.org/html/rfc6052#section-2.2). </description> <metainfo> <attributes/> </metainfo> </class> """ def __init__(self, prefix="64:ff9b::", prefix_mask=96, suffix="::"): """ <method maturity="stable"> <summary> Constructor to initialize a NAT46 instance. </summary> <description> <para> This constructor initializes a NAT46 instance. </para> </description> <metainfo> <arguments> <argument maturity="stable"> <name>prefix</name> <type> <string display_name="Prefix"/> </type> <default>"64:ff9b::"</default> <description>This parameter specifies the common leading part of the IPv6 address that the IPv4 address should map into. Bits that exceed the mask will be overwritten by the mapping.</description> </argument> <argument maturity="stable"> <name>prefix_mask</name> <type> <integer display_name="Prefix netmask"/> </type> <default>96</default> <description>This parameter specifies the position to embed the IPv4 address to and must be one of 32, 40, 48, 56, 64, or 96.</description> </argument> <argument maturity="stable"> <name>suffix</name> <type> <string display_name="Suffix"/> </type> <default>"::"</default> <description>This parameter specifies the common trailing part of the IPv6 address that the IPv4 address should map into. The length of the suffix must not exceed the empty bit count determined by the configured prefix mask.</description> </argument> </arguments> </metainfo> </method> """ super(NAT46, self).__init__() try: self.prefix = socket.inet_pton(socket.AF_INET6, prefix) except socket.error, e: raise UserException, "Invalid prefix string specified; error='%s'" % e try: self.suffix = socket.inet_pton(socket.AF_INET6, suffix) except socket.error, e: raise UserException, "Invalid suffix string specified; error='%s'" % e
def ip_to_bytes(ip): if ":" in ip: # determine if address is IPv6 return socket.inet_pton(socket.AF_INET6, ip) else: return IPV4_PREFIX + socket.inet_pton(socket.AF_INET, ip)
def is_ipv4(addr): try: socket.inet_pton(socket.AF_INET, addr) except socket.error: return False return True
def ip6_to_integer(ip6): ip6 = socket.inet_pton(socket.AF_INET6, ip6) a, b = unpack(">QQ", ip6) return (a << 64) | b
def ip(bot, trigger): """IP Lookup tool""" # Check if there is input at all if not trigger.group(2): return bot.reply("No search term.") # Check whether the input is an IP or hostmask or a nickname decide = ['.', ':'] if any(x in trigger.group(2) for x in decide): # It's an IP/hostname! query = trigger.group(2).strip() else: # Need to get the host for the username username = trigger.group(2).strip() user_in_botdb = bot.users.get(username) if user_in_botdb is not None: query = user_in_botdb.host else: return bot.say("I\'m not aware of this user.") db_path = _find_geoip_db(bot) if db_path is False: LOGGER.error('Can\'t find (or download) usable GeoIP database.') bot.say( 'Sorry, I don\'t have a GeoIP database to use for this lookup.') return False if ':' in query: try: socket.inet_pton(socket.AF_INET6, query) except (OSError, socket.error): # Python 2/3 compatibility return bot.say("[IP/Host Lookup] Unable to resolve IP/Hostname") elif '.' in query: try: socket.inet_pton(socket.AF_INET, query) except (socket.error, socket.herror): try: query = socket.getaddrinfo(query, None)[0][4][0] except socket.gaierror: return bot.say( "[IP/Host Lookup] Unable to resolve IP/Hostname") else: return bot.say("[IP/Host Lookup] Unable to resolve IP/Hostname") city = geoip2.database.Reader(os.path.join(db_path, 'GeoLite2-City.mmdb')) asn = geoip2.database.Reader(os.path.join(db_path, 'GeoLite2-ASN.mmdb')) host = socket.getfqdn(query) try: city_response = city.city(query) asn_response = asn.asn(query) except geoip2.errors.AddressNotFoundError: return bot.say("[IP/Host Lookup] The address is not in the database.") response = "[IP/Host Lookup] Hostname: %s" % host try: response += " | Location: %s" % city_response.country.name except AttributeError: response += ' | Location: Unknown' region = city_response.subdivisions.most_specific.name response += " | Region: %s" % region if region else "" city = city_response.city.name response += " | City: %s" % city if city else "" isp = "AS" + str(asn_response.autonomous_system_number) + \ " " + asn_response.autonomous_system_organization response += " | ISP: %s" % isp if isp else "" bot.say(response)