def __init__(self, arg='::1/128', strict=False): #arg= _RGX_IPV6ADDR_NETMASK.sub(r'\1/\2', arg) # mangle IOS: 'addr mask' self.arg = arg self.dna = "IPv6Obj" try: mm = _RGX_IPV6ADDR.search(arg) except TypeError: if getattr(arg, 'dna', '') == "IPv6Obj": ip_str = '{0}/{1}'.format(str(arg.ip_object), arg.prefixlen) self.network_object = IPv6Network(ip_str, strict=False) self.ip_object = IPv6Address(str(arg.ip_object)) return None elif isinstance(arg, IPv6Network): self.network_object = arg self.ip_object = IPv6Address(str(arg).split('/')[0]) return None elif isinstance(arg, IPv6Address): self.network_object = IPv6Network(str(arg) + '/128') self.ip_object = IPv6Address(str(arg).split('/')[0]) return None else: raise ValueError( "IPv6Obj doesn't understand how to parse {0}".format(arg)) assert (not (mm is None)), "IPv6Obj couldn't parse {0}".format(arg) self.network_object = IPv6Network(arg, strict=strict) self.ip_object = IPv6Address(mm.group(1))
def test_ipv6_order_multi(self): """Test multiple IPv6 ordering.""" t = Interfaces(ucr={ 'interfaces/eth0/ipv6/foo/address': '1:2:3:4:5:6:7:8', 'interfaces/eth0/ipv6/foo/prefix': '64', 'interfaces/eth1/order': '2', 'interfaces/eth1/ipv6/default/address': '1:2:3:4:5:6:7:8', 'interfaces/eth1/ipv6/default/prefix': '64', 'interfaces/eth1/ipv6/a/address': '2:3:4:5:6:7:8:9', 'interfaces/eth1/ipv6/a/prefix': '72', 'interfaces/eth2/order': '1', 'interfaces/eth2/ipv6/z/address': '1:2:3:4:5:6:7:8', 'interfaces/eth2/ipv6/z/prefix': '64', 'interfaces/eth2/ipv6/default/address': '2:3:4:5:6:7:8:9', 'interfaces/eth2/ipv6/default/prefix': '72', 'interfaces/primary': 'eth2,eth1', }) self.assertEqual([], [s.name for _n, s in t.ipv4_interfaces]) self.assertEqual([ ('eth2', 'default'), ('eth2', 'z'), ('eth1', 'default'), ('eth1', 'a'), ('eth0', 'foo')], [(s.name, n) for s, n in t.ipv6_interfaces]) self.assertEqual(IPv6Network('2:3:4:5:6:7:8:9/72'), t.get_default_ip_address()) self.assertEqual(None, t.get_default_ipv4_address()) self.assertEqual(IPv6Network('2:3:4:5:6:7:8:9/72'), t.get_default_ipv6_address())
def _bsd_routingtab_line(self, line): """evaluate one line of OpenBSD routing-table, enter only, if useful content""" zeile = line.split() #print "# rt-read: "+ str(zeile) if len(zeile) > 0: targ = zeile.pop(0) if not ":" in targ: #nice_print("# !!! IPv4 Exception reading routingtable",targ) return try: target = IPv6Network(targ) except: """no IPv6 Address in column one""" #nice_print("# !!! Exception reading routingtable",targ) return try: hop = zeile.pop(0) nhp = IPv6Network(hop.strip()) nhp._prefixlen = 128 dev = zeile.pop(-1) self.routingtab.append([target, nhp, dev]) #print "APPEND:",str([target, nhp, dev]) return except: #print " something wrong reading bsd-routingtable" return
def __read_file(self, filename): """reads file using filename and creates self.entries for every line read successfully """ try: file1 = open(filename, 'r') except: msg = "No readable file: %s" % filename raise ValueError, msg linenr = 0 for zeile in file1: linenr = linenr + 1 line = str(zeile) lefthalf = line.split('#') self.entries.sort(cmp=self.__mycmp__, key=None, reverse=False) try: (name, address) = lefthalf.pop(0).split() try: ipad = IPv6Network(address) if self.entries.count([name, ipad]) == 0: self.entries.append([name, ipad]) except: print "User-Error: file:", filename print "User-Error: line:", linenr print "User-Error: content:", zeile pass finally: pass except: pass self.entries.sort(cmp=self.__mycmp__, key=None, reverse=False)
def network_object(self): try: if self.address_family == 'ip': return IPv4Network('%s/%s' % (self.network, self.netmask)) elif self.address_family == 'ipv6': return IPv6Network('%s/%s' % (self.network, self.netmask)) except: return None
def network(self): """Returns an IPv6Network object, which represents this network. """ if sys.version_info[0] < 3: return self.network_object.network else: ## The ipaddress module returns an "IPAddress" object in Python3... return IPv6Network('{0}'.format(self.network_object.compressed))
def test_ipv6_multi(self): """Test multiple IPv6 interfaces.""" t = Interfaces( ucr={ 'interfaces/eth0/ipv6/default/address': '1:2:3:4:5:6:7:8', 'interfaces/eth0/ipv6/default/prefix': '64', 'interfaces/eth1/ipv6/default/address': '2:3:4:5:6:7:8:9', 'interfaces/eth1/ipv6/default/prefix': '64', }) self.assertEqual([], [s.name for _n, s in t.ipv4_interfaces]) self.assertEqual(['eth0', 'eth1'], [s.name for s, _n in t.ipv6_interfaces]) self.assertEqual(IPv6Network('1:2:3:4:5:6:7:8/64'), t.get_default_ip_address()) self.assertEqual(None, t.get_default_ipv4_address()) self.assertEqual(IPv6Network('1:2:3:4:5:6:7:8/64'), t.get_default_ipv6_address())
def __init__(self, arg='::1/128', strict=False): #arg= _RGX_IPV6ADDR_NETMASK.sub(r'\1/\2', arg) # mangle IOS: 'addr mask' self.arg = arg mm = _RGX_IPV6ADDR.search(arg) assert (not (mm is None)), "IPv6Obj couldn't parse {0}".format(arg) self.network_object = IPv6Network(arg, strict=strict) self.ip_object = IPv6Address(mm.group(1))
def test_ipv6(self): """Test IPv6 functions.""" i = _Iface({ 'name': 'NAME', 'ipv6/default/address': '1:2:3:4:5:6:7:8', 'ipv6/default/prefix': '64', 'ipv6/other/address': '2:3:4:5:6:7:8:9', 'ipv6/other/prefix': '80', }) self.assertEqual('NAME', i.name) self.assertEqual(None, i.ipv4_address()) self.assertEqual(IPv6Network('1:2:3:4:5:6:7:8/64'), i.ipv6_address()) self.assertEqual(IPv6Network('1:2:3:4:5:6:7:8/64'), i.ipv6_address('default')) self.assertEqual(IPv6Network('2:3:4:5:6:7:8:9/80'), i.ipv6_address('other'))
def interface_line(self, line): """evaluate one line of ifconfig-output store results in self.interfaces = [] !!! specific on os-type !!! """ # if 'Win-XP' in self.device_os: # """german version only for now""" # if line.startswith('Schnittstelle '): # righthalf = line.rsplit(':') # ifacename = righthalf.pop(-1).strip() # self.int_name = ifacename # else: # items = line.split() # if len(items) > 1: # targ = items.pop(-1) # try: # target = IPv6Network(targ) # except AddressValueError, e: # """no IPv6 Address in last column """ # return # self.int_addr = target # self.interfaces.append([self.int_name, self.int_addr]) # return nam = re.findall('^[a-z]+[ 0-9][ :] ', line, flags=0) if nam: self.int_name = nam.pop(0).strip() add = [] if 'Linux' in self.device_os: add = re.findall('\s*inet6\ .* Scope:*', line, flags=0) if add: ine = add.pop(0).split() adr = ine.pop(2) self.int_addr = IPv6Network(adr) self.interfaces.append([self.int_name, self.int_addr]) if 'OpenBSD' in self.device_os: if 'inet6' in line: if '%' in line: (le, ri) = line.split('%') else: le = line ine = le.split() adr = ine.pop(1) self.int_addr = IPv6Network(adr) self.interfaces.append([self.int_name, self.int_addr]) return
def convert_udm_subnet_to_ipv6_network(subnet): prefix = subnet.replace(":", "") count = len(prefix) assert 1 <= count <= 32 prefix_length = 4 * count address = subnet if count <= 28: address += "::" return IPv6Network("%s/%d" % (address, prefix_length))
def ip_network(self): if self.afi == 1: ip = IPv4Address(Bytes(self.value[:4])) ipnet = IPv4Network( str(ip) + '/' + str(bytes_to_int(self.value[4]))) else: ip = IPv6Address(Bytes(self.value[:16])) ipnet = IPv6Network( str(ip) + '/' + str(bytes_to_int(self.value[16]))) return IPNetwork(str(ipnet))
def test_06_get_address(self): """ hn-06 get_addrs returns list of given hostname """ file1 = "reference-hostnet" my_err = False try: hn6 = HostNet6(file1) except: my_err = True self.assertFalse(my_err) #print "T6:", hn6.entries #print "GA1", hn6.get_addrs("host-one") #print "GA2", hn6.get_addrs("host-two") self.assertEquals([IPv6Network('2010:db8:1:beed::23/128')], hn6.get_addrs('host-one')) self.assertEquals( \ ('host-one', [IPv6Network('2010:db8:1:beed::23/128')]), \ hn6.show_addr('host-one'))
def test_03_evaluate_entries(self): """ hn-03 evaluate entries of reference-hostnet """ file = "reference-hostnet" content = [ \ ['any', IPv6Network('2000::/3')], \ ['beaf', IPv6Network('2001:db8:beaf::/48')], \ ['host-one', IPv6Network('2010:db8:1:beed::23/128')], \ ['localhost', IPv6Network('::1/128')], \ ['many', IPv6Network('::/0')]] my_err = False try: hn6 = HostNet6(file) print hn6.entries except: my_err = True print content self.assertEquals(content, hn6.entries)
def testIPv6Obj_attributes(): ## Ensure that attributes are accessible and pass the smell test test_object = IPv6Obj("2001::dead:beef/64") results_correct = [ ("ip", IPv6Address("2001::dead:beef")), ("ip_object", IPv6Address("2001::dead:beef")), ("netmask", IPv6Address("ffff:ffff:ffff:ffff::")), ("prefixlen", 64), ("network", IPv6Network("2001::/64")), ("network_object", IPv6Network("2001::/64")), ("hostmask", IPv6Address("::ffff:ffff:ffff:ffff")), ("numhosts", 18446744073709551616), ("version", 6), ("is_reserved", False), ("is_multicast", False), # ("is_private", False), # FIXME: disabling this for now... # py2.7 and py3.x produce different results ("as_cidr_addr", "2001::dead:beef/64"), ("as_cidr_net", "2001::/64"), ("as_decimal", 42540488161975842760550356429036175087), ("as_decimal_network", 42540488161975842760550356425300246528), ( "as_hex_tuple", ("2001", "0000", "0000", "0000", "0000", "0000", "dead", "beef"), ), ( "as_binary_tuple", ( "0010000000000001", "0000000000000000", "0000000000000000", "0000000000000000", "0000000000000000", "0000000000000000", "1101111010101101", "1011111011101111", ), ), ] for attribute, result_correct in results_correct: assert getattr(test_object, attribute) == result_correct
def address_is_own(self, value): """ check, if given address is interface-address of ThisDevice returns Name of Interface or None """ for interface in self.interfaces: [iface_name, target_IP] = interface target = IPv6Network(target_IP) if target.ip == value.ip: return True return False
def test_ipv6_order(self): """Test IPv6 ordering.""" t = Interfaces( ucr={ 'interfaces/eth0/ipv6/default/address': '1:2:3:4:5:6:7:8', 'interfaces/eth0/ipv6/default/prefix': '64', 'interfaces/eth1/ipv6/default/address': '2:3:4:5:6:7:8:9', 'interfaces/eth1/ipv6/default/prefix': '72', 'interfaces/eth2/order': '1', 'interfaces/eth2/ipv6/default/address': '3:4:5:6:7:8:9:a', 'interfaces/eth2/ipv6/default/prefix': '80', }) self.assertEqual([], [s.name for _n, s in t.ipv4_interfaces]) self.assertEqual(['eth2', 'eth0', 'eth1'], [s.name for s, _n in t.ipv6_interfaces]) self.assertEqual(IPv6Network('1:2:3:4:5:6:7:8/64'), t.get_default_ip_address()) self.assertEqual(None, t.get_default_ipv4_address()) self.assertEqual(IPv6Network('1:2:3:4:5:6:7:8/64'), t.get_default_ipv6_address())
def _debian_routingtab_line(self, line): """ evaluate one line of debian ipv6 routingtable and append it to routingtab, which is a list of routing entries """ words = line.split() w1 = words.pop(0).strip() if not line.find("unreachable"): return if not line.find("default") and line.find("via") > 0: target = '::/0' via = words.pop(1) interf = words.pop(2) else: target = w1 if line.find("via") == -1: interf = words.pop(1) via = "::/0" else: via = words.pop(1) interf = words.pop(2) self.routingtab.append([IPv6Network(target), IPv6Network(via), interf])
def test_04_evaluate_appended_entries_fail(self): """ hn-04 entries of reference-hostnet-fail are not appended """ file1 = "reference-hostnet" file2 = "reference-hostnet-fail" content = [ \ ['any', IPv6Network('2000::/3')], \ ['beaf', IPv6Network('2001:db8:beaf::/48')], \ ['host-one', IPv6Network('2010:db8:1:beed::23/128')], \ ['localhost', IPv6Network('::1/128')], \ ['many', IPv6Network('::/0')]] my_err = False try: hn6 = HostNet6(file1) except: my_err = True try: hn6.append(file2) except: my_err = True self.assertTrue(my_err) #print "HN:", hn6.entries self.assertEquals(content, hn6.entries)
def to_dict(self): d = {} for name, _ in self.__class__.fields: d[name] = getattr(self, name) if name in ('to', ): d[name] = '0x' + encode_hex(d[name]) elif name in ('value', ): if self.afi == 1: ip = IPv4Address(Bytes(d[name][:4])) net = IPv4Network( str(ip) + '/' + str(bytes_to_int(d[name][4]))) d[name] = str(net) else: ip = IPv6Address(Bytes(d[name][:16])) net = IPv6Network( str(ip) + '/' + str(bytes_to_int(d[name][16]))) d[name] = str(net) elif name in ('metadata', ) and self.category == 2: _metadata = [] i = 0 while i < len(d[name]): _metadata.append(bytes_to_int(d[name][i])) if _metadata[-1] == 1: ip = IPv4Address(Bytes(d[name][i + 1])) else: ip = IPv6Address(Bytes(d[name][i + 1])) _metadata.append(str(ip)) _metadata.append(encode_hex(d[name][i + 2])) i += 3 d[name] = _metadata elif name in ('metadata', ) and self.category == 3: _metadata = [] i = 0 while i < len(d[name]): _metadata.append(bytes_to_int(d[name][i])) if _metadata[-1] == 1: ip = IPv4Address(Bytes(d[name][i + 1])) else: ip = IPv6Address(Bytes(d[name][i + 1])) _metadata.append(str(ip)) _metadata.append(bytes_to_int(d[name][i + 2])) _metadata.append(bytes_to_int(d[name][i + 3])) i += 4 d[name] = _metadata d['sender'] = '0x' + encode_hex(self.sender) d['hash'] = '0x' + encode_hex(self.hash) return d
def test_ipv6_disjunct(self): """Test disjunct IPv4 IPv6 interfaces.""" t = Interfaces( ucr={ 'interfaces/eth0/address': '2.3.4.5', 'interfaces/eth0/netmask': '255.255.255.0', 'interfaces/eth1/ipv6/default/address': '1:2:3:4:5:6:7:8', 'interfaces/eth1/ipv6/default/prefix': '64', }) self.assertEqual(['eth0'], [s.name for _n, s in t.ipv4_interfaces]) self.assertEqual(['eth1'], [s.name for s, _n in t.ipv6_interfaces]) self.assertEqual(IPv4Network('2.3.4.5/24'), t.get_default_ip_address()) self.assertEqual(IPv4Network('2.3.4.5/24'), t.get_default_ipv4_address()) self.assertEqual(IPv6Network('1:2:3:4:5:6:7:8/64'), t.get_default_ipv6_address())
def look_for(self, addr): """ seeks addr in routing-table, returns tuple of interface-name and line number of routing-entry """ interface = u'undef' route_number = -1 ad = IPv6Network(addr) #print "LOOK_for: " + str(ad), for route in self.routingtab: route_number += 1 (rte, nhp, dev) = route result = rte.__contains__(ad) if result: interface = dev #print "RETURN1: " + str(interface) + " Line: "+ str(route_number) return (interface, route_number) #print "RETURN2: " + str(interface) + " Line: "+ str(route_number) return (interface, route_number)
def test_05_evaluate_appended_entries_ok(self): """ hn-05 entries of reference-hostnet-append are appended """ file1 = "reference-hostnet" file2 = "reference-hostnet-append" content = [ \ ['any', IPv6Network('2000::/3')], \ ['beaf', IPv6Network('2001:db8:beaf::/48')], \ ['host-one', IPv6Network('2010:db8:1:beed::23/128')], \ ['host-one', IPv6Network('2010:db8:1:beed::6/128')], \ ['host-two', IPv6Network('2010:db8:1:beed::7/128')], \ ['localhost', IPv6Network('::1/128')], \ ['many', IPv6Network('::/0')]] my_err = False try: hn6 = HostNet6(file1) hn6.append(file2) except: my_err = True self.assertEquals(content, hn6.entries)
asns = asns.split() assert asns except Exception: if DEBUG: print_exc() sys.exit(1) asns = [asn.replace('AS', '') for asn in asns] nets = list() collapsed = None for asn in asns: try: result = db.get_as_prefixes(asn) if result: for net in result: if IPNetwork(net).version == 4 and IPNetwork( net).version == af: nets.append(IPv4Network(net)) if IPNetwork(net).version == 6 and IPNetwork( net).version == af: nets.append(IPv6Network(net)) collapsed = [str(net) for net in collapse_address_list(nets)] except Exception: if DEBUG: print_exc() pass if collapsed: print '\n'.join(collapsed)
class user_ipv6: address = IPv6Network("2001:db8:0::/48") gateway = IPv6Address("2001:db8:0::1") reserved_addresses_bottom = 10 reserved_addresses_top = 2 vlan = VLANData.vlan_dummy1
def ipv6_address(self, name='default'): """Return IPv6 address.""" key = '%%(ipv6/%s/address)s/%%(ipv6/%s/prefix)s' % (name, name) return IPv6Network(key % self)
def prefixlen(self, arg): """prefixlen setter method""" self.network_object = IPv6Network("{0}/{1}".format( str(self.ip_object), arg), strict=False)
def __init__(self, nonce, category, to, afi, value, metadata=b'', time=0, v=0, r=0, s=0): if category == 0 or category == 1: if metadata != b'': raise InvalidTransaction("Invalid Metadata") metadata = b'' elif category == 2: if type(metadata) == list and len(metadata) % 3 == 0: _metadata = [] _afi = 0 if type(metadata[0]) == bytes: _bytes = True elif type(metadata[0]) == int: _bytes = False else: raise InvalidTransaction("Invalid Metadata") i = 0 while i < len(metadata): try: if _bytes: _afi = bytes_to_int(metadata[i]) _metadata.append(metadata[i]) else: _afi = metadata[i] _metadata.append(encode_int8(metadata[i])) if _afi != 1 and _afi != 2: raise InvalidTransaction("Invalid Metadata AFI") except: raise InvalidTransaction("Invalid Metadata AFI") try: if _bytes: if _afi == 1: ip = IPv4Address(Bytes(metadata[i + 1])) else: ip = IPv6Address(Bytes(metadata[i + 1])) _metadata.append(bytes(ip.packed)) addr = normalize_address(metadata[i + 2], allow_blank=True) _metadata.append(addr) else: if _afi == 1: ip = IPv4Address(metadata[i + 1]) else: ip = IPv6Address(metadata[i + 1]) _metadata.append(bytes(ip.packed)) addr = normalize_address(metadata[i + 2], allow_blank=True) _metadata.append(addr) i += 3 except: raise InvalidTransaction("Invalid Metadata") metadata = _metadata else: raise InvalidTransaction("Invalid Metadata") elif category == 3: if type(metadata) == list and len(metadata) % 4 == 0: _metadata = [] _afi = 0 if type(metadata[0]) == bytes: _bytes = True elif type(metadata[0]) == int: _bytes = False else: raise InvalidTransaction("Invalid Metadata") i = 0 while i < len(metadata): try: if _bytes: _afi = bytes_to_int(metadata[i]) _metadata.append(metadata[i]) else: _afi = metadata[i] _metadata.append(encode_int8(metadata[i])) if _afi != 1 and _afi != 2: raise InvalidTransaction("Invalid Metadata AFI") except: raise InvalidTransaction("Invalid Metadata AFI") try: if _bytes: if _afi == 1: ip = IPv4Address(Bytes(metadata[i + 1])) else: ip = IPv6Address(Bytes(metadata[i + 1])) _metadata.append(bytes(ip.packed)) priority = bytes_to_int(metadata[i + 2]) if priority < 0 or priority > 255: raise InvalidTransaction( "Invalid Metadata Priority") _metadata.append(int_to_bytes(priority)) weight = bytes_to_int(metadata[i + 3]) if weight < 0 or weight > 255: raise InvalidTransaction( "Invalid Metadata Weight") _metadata.append(int_to_bytes(weight)) else: if _afi == 1: ip = IPv4Address(metadata[i + 1]) else: ip = IPv6Address(metadata[i + 1]) _metadata.append(bytes(ip.packed)) priority = metadata[i + 2] if priority < 0 or priority > 255: raise InvalidTransaction( "Invalid Metadata Priority") _metadata.append(int_to_bytes(priority)) weight = metadata[i + 3] if weight < 0 or weight > 255: raise InvalidTransaction( "Invalid Metadata Weight") _metadata.append(int_to_bytes(weight)) i += 4 except: raise InvalidTransaction("Invalid Metadata") metadata = _metadata else: raise InvalidTransaction("Invalid Metadata") else: raise InvalidTransaction("Invalid Category") to = normalize_address(to, allow_blank=True) if afi != 1 and afi != 2: raise InvalidTransaction("Invalid AFI") try: if afi == 1: ipnet = IPv4Network(value) else: ipnet = IPv6Network(value) except: if len(value) == 5: try: ip = IPv4Address(Bytes(value[:4])) ipnet = IPv4Network( str(ip) + '/' + str(bytes_to_int(value[4]))) except: raise InvalidTransaction("Invalid Value") elif len(value) == 17: try: ip = IPv6Address(Bytes(value[:16])) ipnet = IPv6Network( str(ip) + '/' + str(bytes_to_int(value[16]))) except: raise InvalidTransaction("Invalid Value") else: raise InvalidTransaction("Invalid Value") value = bytes(ipnet.packed) + encode_int8(ipnet.prefixlen) super(Transaction, self).__init__(nonce, category, to, afi, value, metadata, time, v, r, s)