Пример #1
0
    def clean(self):
        super(Prefix4, self).clean()
        prefix = self.prefix
        if re.match(r'(\d{1,3}\.){3}\d{1,3}[\s]*$', prefix):
            self.prefix = prefix + '/32'
        elif re.match(r'(\d{1,3}\.){3}\d{1,3}/\d{1,2}', prefix):
            pass
        else:
            raise ValidationError(u'Invalid network prefix "{0}"'.format(prefix))
        network = Network(str(self.prefix))

        if network.network().dq != network.dq:
            raise ValidationError(u'Invalid prefix length /{0}'
                                  u' for the network {1}'.format(self.prefix.split('/')[1], self.prefix.split('/')[0]))

        # qs = self.vrf_list(exclude_self=True)

        if not self.find_parent() and not self.domain:
            ValidationError(u'Top-level prefix must have domain name')

        if self.status in BLOCK_STATUSES:
            p = self.prefixes_lower(statuses=BLOCK_STATUSES).first()
            if not p:
                p = self.prefixes_upper(statuses=BLOCK_STATUSES).last()
            if p:
                raise ValidationError(u'Network {0} is already {1}'.format(p.prefix, p.get_status_display().lower()))
Пример #2
0
def is_private_ip(ip):
    try:
        network = Network(ip)
        if network.info() == "PRIVATE":
            return ip
    except ValueError as e:
        return
Пример #3
0
 def _do_interfaces():
     net = Network('{}'.format(kwargs['ipvpn_ipnet']))
     ipv6net = Network(u'{}'.format(kwargs['ipvpn_ipv6net']))
     template = env.get_template('ipvpn/interfaces.j2')
     vpns = [str(vpn) for vpn in range(args.vid, args.vid + args.nvpns)]
     outer_offest, inner_offset = kwargs['vlan_offsets'].split(' ')
     return template.render({
         'vpns':
         vpns,
         'units':
         range(args.nid, args.nid + args.nu),
         'base_interface':
         kwargs['base_interface'],
         'subnets': [net + i * 256 for i in range(1, args.nu + 1)],
         'v6subnets': [ipv6net + i * 65536 for i in range(1, args.nu + 1)],
         'gw':
         1,
         'inner_vlans':
         list(range(1, args.nu + 1)),
         'nu':
         args.nu,
         'inner_offset':
         int(inner_offset),
         'outer_offset':
         int(outer_offest)
     })
Пример #4
0
 def __init__(self, val, config):
     self.private_networks = [
         Network("127.0.0.0/8"),
         Network("10.0.0.0/8"),
         Network("172.16.0.0/12"),
         Network("192.168.0.0/16"),
     ]
Пример #5
0
 def search_free(vrf, network, statuses):
     """
     Free blocks recursive search
     :param vrf: VRF
     :type vrf: Vrf
     :param network:  Network
     :type network: Network
     """
     f_ip = network.ip
     l_ip = network.broadcast_long()
     size = network.size()
     blocked_size = \
         vrf.prefixes().filter(status__in=statuses, first_ip_dec__gte=f_ip, last_ip_dec__lte=l_ip).aggregate(
             sum_size=Sum('size'))['sum_size']
     if not blocked_size:
         blocked_size = 0
     if size == blocked_size:
         return []
     elif blocked_size == 0:
         if vrf.prefixes().filter(first_ip_dec__lte=f_ip, last_ip_dec__gte=l_ip):
             parent = vrf.prefixes().filter(first_ip_dec__lte=f_ip, last_ip_dec__gte=l_ip).last()
         else:
             parent = None
         if size == 1:
             create_url = '{0}?prefix={1}'.format(reverse_lazy('ipam.host4_add', kwargs={'vrf': vrf.name}),
                                                  network.dq)
         else:
             create_url = '{0}?prefix={1}'.format(reverse_lazy('ipam.prefix4_add', kwargs={'vrf': vrf.name}),
                                                  network)
         return [{'prefix': str(network), 'parent': parent, 'create_url': create_url}]
     else:
         net_1 = Network('{0}/{1}'.format(network.to_tuple()[0], network.to_tuple()[1] + 1))
         net_2 = Network('{0}/{1}'.format(IP(net_1.broadcast_long() + 1).dq, network.subnet() + 1))
         return search_free(vrf, net_1, statuses) + search_free(vrf, net_2, statuses)
Пример #6
0
    def prefixes_lower(self, root_only=False, networks_only=False, hosts_only=False, statuses=None,
                       ignore_stored_values=False):
        if self.id and root_only and not ignore_stored_values:
            args = {}
            if networks_only:
                args['size__gt'] = 1
            elif hosts_only:
                args['size'] = 1
            if statuses:
                args['status__in'] = statuses
            return self.child if len(args) == 0 else self.child.filter(**args)

        network = Network(str(self.prefix))
        f_ip = network.ip
        l_ip = network.broadcast_long()
        qs = self.vrf.prefixes(
            networks_only=networks_only,
            hosts_only=hosts_only,
            statuses=statuses).filter(first_ip_dec__gte=f_ip, last_ip_dec__lte=l_ip)
        if ignore_stored_values:
            # TODO Add check with ignoring stored data
            pass
        else:
            if self.id:
                qs = qs.exclude(id=self.id)
            if root_only:
                return qs.filter(parent=self.find_parent())
            else:
                return qs
Пример #7
0
 def do_GET(self):
     do_block = True
     if len(allowedIP) > 1:
         for net in allowedIP:
             if self.client_address[0] in Network(net):
                 do_block = False
     else:
         if self.client_address[0] in Network(allowedIP[0]):
             do_block = False
     if do_block:
         self.send_error(401)
         return
     # Проверка на валидность переданой строки
     if not re.match(r"^/[\w_\-\:]*$", self.path):
         self.send_error(400, "Wrong request string: %s" % self.path)
         return
     # In [1]: "/vz-list:some".lstrip("/").split(":")
     # Out[1]: ['vz-list', 'some']
     # In [2]: "/vz-list".lstrip("/").split(":")
     # Out[2]: ['vz-list']
     cmds = self.path.lstrip("/").split(":")
     resp = ""
     for cmd in cmds:
         if cmd == "" and defaultCmd:
             cmd = defaultCmd
         if cmd in conf["commands"].keys():
             resp += cmd_exec(conf["commands"][cmd])
         else:
             self.send_error(404, "The command \"%s\" doesn't exist" % cmd)
             return
     if resp:
         self.send_response(200)
         self.end_headers()
         self.wfile.write("%s" % resp)
Пример #8
0
def is_private(ip):
    try:
        network = Network(ip)
        if network.info() == "PRIVATE":
            return True
        return False
    except ValueError as e:
        return
Пример #9
0
 def prefixes_upper(self, networks_only=False, hosts_only=False, statuses=None):
     network = Network(str(self.prefix))
     f_ip = network.ip
     l_ip = network.broadcast_long()
     if self.id:
         return self.vrf.prefixes(networks_only=networks_only, hosts_only=hosts_only, statuses=statuses).filter(
             first_ip_dec__lte=f_ip, last_ip_dec__gte=l_ip, size__gt=network.size()).exclude(id=self.id)
     else:
         return self.vrf.prefixes(networks_only=networks_only, hosts_only=hosts_only, statuses=statuses).filter(
             first_ip_dec__lte=f_ip, last_ip_dec__gte=l_ip, size__gt=network.size())
Пример #10
0
    def test_calculation(self):
        self.assertEqual(self.network[1].subnet(), 24)

        a = Network('192.168.0.100/28')
        self.assertEqual(str(a), '192.168.0.100/28')
        self.assertEqual(a.size(), 16)
        self.assertEqual(a.size(), len(a))
        self.assertEqual(int(a), 0xC0A80064)
        for i in range(a.size()):
            self.assertEqual(int(a[i]), i + 0xC0A80064)

        self.assertRaises(IndexError, lambda: a[a.size()])
Пример #11
0
def search(user, search_args):
    """

    :param user: User
    :type user: django.contrib.auth.models.User
    :param search_args: String list
    :type search_args: list
    :return: List of results: {title, utl, description, module}
    """
    if not user.has_perms(['ipam.view', ]):
        return []
    else:
        ip = None
        string_args = []
        ip_reg_exp = re.compile('(\d{1,3}\.)\d{1,3}(/\d{1,3})?')
        for line in search_args:
            if ip_reg_exp.match(line) and not ip:
                ip = line if '/' in line else line + '/32'
            else:
                string_args.append(line)

        objects = []

        # Search Prefix4
        qs = Prefix4.objects.all()
        if ip:
            network = Network(ip)
            f_ip = network.ip
            l_ip = network.broadcast_long()
            qs = qs.filter(first_ip_dec__lte=f_ip, last_ip_dec__gte=l_ip)
            for s in string_args:
                qs = qs.filter(Q(description__icontains=s) | Q(status__icontains=s) | Q(domain__icontains=s) | Q(
                    host_name__icontains=s))
            if qs:
                objects.append(qs.last())
        qs = Prefix4.objects.all()
        for s in search_args:
            qs = qs.filter(Q(description__icontains=s) | Q(status__icontains=s) | Q(domain__icontains=s) | Q(
                host_name__icontains=s) | Q(prefix__icontains=s))
        for prefix in qs:
            if prefix not in objects:
                objects.append(prefix)

        qs = Vrf.objects.all()
        for s in search_args:
            qs = qs.filter(Q(description__icontains=s) | Q(rd__icontains=s) | Q(name__icontains=s))
        for vrf in qs:
            if vrf not in objects:
                objects.append(vrf)

        return [{'title': str(o), 'url': o.get_absolute_url(), 'description': o.description, 'module': 'IPAM'} for o in
                objects]
Пример #12
0
def get_network(ip_range):
    """
    Get network from provided IP
    :param ip_range:
    :return:
    """
    try:
        ip = Network(ip_range)
        network = "{}/{}".format(str(ip.network()), str(ip.subnet()))
    except ValueError as e:
        current_app.logger.debug(e)
        return
    return network
Пример #13
0
class TestNetwork(unittest.TestCase):

    """Tests for Network."""

    def setUp(self):
        self.network = Network('192.168.11.0/255.255.255.0')

    def test_calculation(self):
        self.assertEqual(self.network[1].subnet(), 24)

        a = Network('192.168.0.100/28')
        self.assertEqual(str(a), '192.168.0.100/28')
        self.assertEqual(a.size(), 16)
        self.assertEqual(a.size(), len(a))
        self.assertEqual(int(a), 0xC0A80064)
        for i in range(a.size()):
            self.assertEqual(int(a[i]), i + 0xC0A80064)

        self.assertRaises(IndexError, lambda: a[a.size()])

    def test_indexers(self):
        expected = range(int(0xC0A80B00), int(0xC0A80C00))
        self.assertEqual(self.network.size(), len(expected))
        for i in range(self.network.size()):
            self.assertEqual(int(self.network[i]), expected[i])
        self.assertEqual(int(self.network[-1]), expected[-1])

    def test_contains(self):
        self.assertTrue(IP('192.168.11.0') in self.network)
        self.assertTrue(IP('192.168.11.1') in self.network)
        self.assertTrue(IP('192.168.11.255') in self.network)

    def test_eq_le_gt(self):
        self.assertEqual(Network('192.168.11.0'), Network('192.168.11.0'))
        self.assertEqual(Network('192.168.11.0/32'), Network('192.168.11.0'))
        self.assertEqual(Network('192.168.11.0'), IP('192.168.11.0'))
        self.assertEqual(Network('192.168.11.0/32'), IP('192.168.11.0'))

        self.assertNotEqual(Network('192.168.11.0/28'), Network('192.168.11.0/24'))
        self.assertNotEqual(Network('192.168.11.0'), Network('192.168.11.1'))
        self.assertNotEqual(Network('192.168.11.0'), Network('192.168.2.1'))
        self.assertNotEqual(Network('192.168.11.0/30'), IP('192.168.11.0'))
        self.assertNotEqual(Network('192.168.1.0'), IP('192.168.11.0'))

        self.assertTrue(Network('192.168.1.0/30') < Network('192.168.1.0/29'))
        self.assertTrue(Network('192.168.1.0/30') <= Network('192.168.1.0/29'))
        self.assertTrue(Network('192.168.1.0/30') <= Network('192.168.1.0/30'))

        self.assertTrue(Network('192.168.1.0/28') > Network('192.168.1.0/29'))
        self.assertTrue(Network('192.168.1.0/28') >= Network('192.168.1.0/29'))
        self.assertTrue(Network('192.168.1.0/28') >= Network('192.168.1.0/28'))
Пример #14
0
    def get_context_data(self, **kwargs):
        from django.db.models import Sum
        from ipam.models import BLOCK_STATUSES

        def search_free(vrf, network, statuses):
            """
            Free blocks recursive search
            :param vrf: VRF
            :type vrf: Vrf
            :param network:  Network
            :type network: Network
            """
            f_ip = network.ip
            l_ip = network.broadcast_long()
            size = network.size()
            blocked_size = \
                vrf.prefixes().filter(status__in=statuses, first_ip_dec__gte=f_ip, last_ip_dec__lte=l_ip).aggregate(
                    sum_size=Sum('size'))['sum_size']
            if not blocked_size:
                blocked_size = 0
            if size == blocked_size:
                return []
            elif blocked_size == 0:
                if vrf.prefixes().filter(first_ip_dec__lte=f_ip, last_ip_dec__gte=l_ip):
                    parent = vrf.prefixes().filter(first_ip_dec__lte=f_ip, last_ip_dec__gte=l_ip).last()
                else:
                    parent = None
                if size == 1:
                    create_url = '{0}?prefix={1}'.format(reverse_lazy('ipam.host4_add', kwargs={'vrf': vrf.name}),
                                                         network.dq)
                else:
                    create_url = '{0}?prefix={1}'.format(reverse_lazy('ipam.prefix4_add', kwargs={'vrf': vrf.name}),
                                                         network)
                return [{'prefix': str(network), 'parent': parent, 'create_url': create_url}]
            else:
                net_1 = Network('{0}/{1}'.format(network.to_tuple()[0], network.to_tuple()[1] + 1))
                net_2 = Network('{0}/{1}'.format(IP(net_1.broadcast_long() + 1).dq, network.subnet() + 1))
                return search_free(vrf, net_1, statuses) + search_free(vrf, net_2, statuses)

        context = super(FreeBlocks4ReportView, self).get_context_data(**kwargs)
        context['page_title'] = u'Free IPv4 Blocks'
        if 'vrf' in self.request.GET and 'prefix' in self.request.GET:
            if Vrf.objects.filter(name=self.request.GET['vrf']):
                net = Network(self.request.GET['prefix'])
                if net.dq != net.network():
                    net = Network('{0}/{1}'.format(net.network(), net.subnet()))
                context['report'] = search_free(Vrf.objects.get(name=self.request.GET['vrf']), net, BLOCK_STATUSES)
                context['total'] = len(context['report'])
        return context
Пример #15
0
def new_isp_ip():
    with open('new_isp_ip.txt', 'w') as f:
        for line in open('isp_ip.txt'):
            line = line.strip()
            if line:
                elems = [e.strip() for e in line.split('/')]
                try:
                    mask = int(elems[1])
                except ValueError:
                    f.write(','.join(elems) + '\n')
                    continue
                network = Network(elems[0], mask=mask)
                elems[0] = network.network().dq
                elems[1] = network.broadcast().dq
                f.write(','.join(elems) + '\n')
Пример #16
0
 def _parse_ip(self, directive: str):
     parts = directive.split('-')
     if len(parts) > 1:
         return IPRange(IP(parts[0]), IP(parts[1]))
     if '/' in parts[0]:
         return Network(parts[0])
     return IP(parts[0])
Пример #17
0
def get_network(network_addr):
    if not network_addr:
        print exit("no network IP address defined", 1)
    try:
        return Network(network_addr)
    except ValueError as e:
        print exit(e, 1)
Пример #18
0
def validate_ip_in_range(subnet_ip, address_prefix):
    try:
        ips = Network(address_prefix)
        if subnet_ip in ips:
            return True
    except ValueError as e:
        current_app.logger.debug(e)
        return
Пример #19
0
 def test_ipv4_3(self):
     net = Network('10.10.0.0/255.255.255.0')
     self.assertTrue(str(net) == '10.10.0.0/24')
     self.assertTrue(str(net.to_ipv6().to_compressed()) == '2002:a0a::')
     self.assertTrue(net.info() == 'PRIVATE')
     self.assertTrue(net.subnet() == 24)
     self.assertTrue(net.size() == 1 << (32 - 24))
     self.assertTrue(int(net) == 0x0a0a0000)
     self.assertTrue(net.hex().lower() == '0a0a0000')
     self.assertTrue(str(net.netmask()) == '255.255.255.0')
     self.assertTrue(net.version() == 4)
     self.assertTrue(str(net.network()) == '10.10.0.0')
     self.assertTrue(str(net.broadcast()) == '10.10.0.255')
     self.assertFalse('192.168.0.1' in net)
     self.assertFalse('192.168.114.128' in net)
     self.assertFalse('10.0.0.1' in net)
     self.assertTrue('10.10.0.254' in net)
     self.assertTrue('10.10.0.100' in net)
Пример #20
0
def is_overlapping_range(ip_range, subnetworks):
    """
    This method checks for IP range collision
    :return:
    """
    if not subnetworks:
        return

    try:
        ip_range = Network(ip_range)
        for subnet in subnetworks:
            subnet = Network(subnet)
            if ip_range.check_collision(subnet):
                return True

    except ValueError as e:
        current_app.logger.debug(e)
        return
Пример #21
0
 def test_ipv4_3(self):
     net = Network("10.10.0.0/255.255.255.0")
     self.assertTrue(str(net) == "10.10.0.0/24")
     self.assertTrue(str(net.to_ipv6().to_compressed()) == "2002:a0a::")
     self.assertTrue(net.info() == "PRIVATE")
     self.assertTrue(net.subnet() == 24)
     self.assertTrue(net.size() == 1 << (32 - 24))
     self.assertTrue(int(net) == 0x0A0A0000)
     self.assertTrue(net.hex().lower() == "0a0a0000")
     self.assertTrue(str(net.netmask()) == "255.255.255.0")
     self.assertTrue(net.version() == 4)
     self.assertTrue(str(net.network()) == "10.10.0.0")
     self.assertTrue(str(net.broadcast()) == "10.10.0.255")
     self.assertFalse("192.168.0.1" in net)
     self.assertFalse("192.168.114.128" in net)
     self.assertFalse("10.0.0.1" in net)
     self.assertTrue("10.10.0.254" in net)
     self.assertTrue("10.10.0.100" in net)
Пример #22
0
def test_ip(method, ip):
    my_ip = IP(ip)
    network = Network("10.0.0.0/12")
    net_list = list(network)

    if method == "bin":
        return bin_search(net_list, my_ip)
    else:
        return lin_search(net_list, my_ip)
Пример #23
0
def validate_ip_range(ip_range):
    """
    Validate Ip range
    :return:
    """
    try:
        ips = Network(ip_range)
    except ValueError as e:
        current_app.logger.debug(e)
        return
    return True
Пример #24
0
 def test_ipv4_1(self):
     net = Network('192.168.114.42', 23)
     self.assertTrue(str(net) == '192.168.114.42/23')
     self.assertTrue(str(net.to_ipv6().to_compressed()) == '2002:c0a8:722a::')
     self.assertTrue(net.info() == 'PRIVATE')
     self.assertTrue(net.subnet() == 23)
     self.assertTrue(net.size() == 1 << (32 - 23))
     self.assertTrue(int(net) == 0xc0a8722a)
     self.assertTrue(net.hex().lower() == 'c0a8722a')
     self.assertTrue(str(net.netmask()) == '255.255.254.0')
     self.assertTrue(net.version() == 4)
     self.assertTrue(str(net.network()) == '192.168.114.0')
     self.assertTrue(str(net.broadcast()) == '192.168.115.255')
     self.assertFalse('192.168.0.1' in net)
     self.assertTrue('192.168.114.128' in net)
     self.assertFalse('10.0.0.1' in net)
     self.assertTrue(str(net + 6) == '192.168.114.48/23')
     self.assertTrue((net + 6) in net)
     self.assertTrue(str(net - 6) == '192.168.114.36/23')
     self.assertTrue((net - 6) in net)
Пример #25
0
 def test_ipv4_1(self):
     net = Network("192.168.114.42", 23)
     self.assertTrue(str(net) == "192.168.114.42/23")
     self.assertTrue(str(net.to_ipv6().to_compressed()) == "2002:c0a8:722a::")
     self.assertTrue(net.info() == "PRIVATE")
     self.assertTrue(net.subnet() == 23)
     self.assertTrue(net.size() == 1 << (32 - 23))
     self.assertTrue(int(net) == 0xC0A8722A)
     self.assertTrue(net.hex().lower() == "c0a8722a")
     self.assertTrue(str(net.netmask()) == "255.255.254.0")
     self.assertTrue(net.version() == 4)
     self.assertTrue(str(net.network()) == "192.168.114.0")
     self.assertTrue(str(net.broadcast()) == "192.168.115.255")
     self.assertFalse("192.168.0.1" in net)
     self.assertTrue("192.168.114.128" in net)
     self.assertFalse("10.0.0.1" in net)
     self.assertTrue(str(net + 6) == "192.168.114.48/23")
     self.assertTrue((net + 6) in net)
     self.assertTrue(str(net - 6) == "192.168.114.36/23")
     self.assertTrue((net - 6) in net)
Пример #26
0
def get_subnet_cidr_block(address_prefix, host_count):
    """
    This method exctracts the required host addresses from the address prefix, returns the
    updated host prefix and ip range
    :return:
    """
    try:
        address_prefix = Network(address_prefix)
        cidr_block_size = get_cidr_block_size(host_count)
        split_address = str(address_prefix).split("/")
        if not len(split_address) == 2:
            return

        ip_range = split_address[0] + cidr_block_size
        address_prefix = address_prefix.__add__(int(host_count))

    except ValueError as e:
        current_app.logger.debug(e)
        return

    return ip_range, address_prefix
    def add_network_cidr_mapping(self,
                                 network_config):
        """
        Method calculates and adds a CloudFormation mapping that is used to set VPC and Subnet CIDR blocks.  Calculated based on CIDR block sizes and additionally checks to ensure all network segments fit inside of the specified overall VPC CIDR
        @param network_config [dict] dictionary of values containing data for creating
        """
        az_count = int(network_config.get('az_count', '2'))
        network_cidr_base = str(network_config.get('network_cidr_base', '172.16.0.0'))
        network_cidr_size = str(network_config.get('network_cidr_size', '20'))
        first_network_address_block = str(network_config.get('first_network_address_block', network_cidr_base))

        ret_val = {}
        cidr_info = Network(network_cidr_base + '/' + network_cidr_size)
        base_cidr = cidr_info.network().to_tuple()[0] + '/' + str(cidr_info.to_tuple()[1])
        ret_val['vpcBase'] = {'cidr': base_cidr}
        current_base_address = first_network_address_block

        subnet_types = network_config.get('subnet_types', ['public', 'private'])

        for index in range(0, len(subnet_types)):
            subnet_type = subnet_types[index]
            subnet_size = network_config.get(subnet_type + '_subnet_size', '22')

            if index != 0:
                range_reset = Network(current_base_address + '/' + str(subnet_size))
                current_base_address = IP(int(range_reset.host_last().hex(), 16) + 2).to_tuple()[0]

            for subnet_id in range(0, az_count):
                if not cidr_info.check_collision(current_base_address):
                    raise RuntimeError('Cannot continue creating network--current base address is outside the range of the master Cidr block. Found on pass ' + str(index + 1) + ' when creating ' + subnet_type + ' subnet cidrs')
                ip_info = Network(current_base_address + '/' + str(subnet_size))
                range_info = ip_info.network().to_tuple()
                if 'subnet' + str(subnet_id) not in ret_val:
                    ret_val['subnet' + str(subnet_id)] = dict()
                ret_val['subnet' + str(subnet_id)][subnet_type] = ip_info.network().to_tuple()[0] + '/' + str(ip_info.to_tuple()[1])
                current_base_address = IP(int(ip_info.host_last().hex(), 16) + 2).to_tuple()[0]

        return self.template.add_mapping('networkAddresses', ret_val)
Пример #28
0
    def prefixes(self, root_only=False, networks_only=False, hosts_only=False, statuses=None, subnet=None,
                 recursion=False):
        """
        Return QuerySet with VRF's prefixes
        :param root_only: return top-level's prefixes only
        :type root_only: bool
        :param networks_only: return networks only (without hosts)
        :type networks_only: bool
        :param hosts_only: return hosts only (without networks)
        :type hosts_only: bool
        :param statuses: statuses list for filter
        :type statuses: list
        :param recursion: Include children VRFs
        :type recursion: bool
        :return: QuerySet
        :rtype: django.db.models.QuerySet
        """

        args = {}
        if statuses:
            args['status__in'] = statuses
        if root_only:
            args['parent'] = None
        if networks_only:
            args['size__gt'] = 1
        elif hosts_only:
            args['size'] = 1
        if subnet:
            network = Network(subnet)
            args['first_ip_dec__gte'] = network.ip
            args['last_ip_dec__lte'] = network.broadcast_long()
        if recursion:
            args['vrf__in'] = self.recursive_children()
            return Prefix4.objects.filter(**args)
        else:
            return self.prefixes_list if len(args) == 0 else self.prefixes_list.filter(**args)
Пример #29
0
    def echo(self, ip: str) -> None:
        """
        Send ping echo request to destination
        :param ip: destination IP
        :return: None
        """
        ip_count = 5
        args = ip.split(" ")
        if len(args) == 3:
            if args[0] == "-c":
                ip_count = (int)(args[1])
                ip = args[2]
        elif len(args) == 1:
            ip = args[0]

        # convert str to IP address object
        ip = IP(ip)
        # iterate over all interfaces on device to find connected route
        #print(self.interfaces)
        for name, data in self.interfaces.items():
            # print(name)
            # find connected interface by checking if destination IP is included in our interface subnets
            if ip in Network(data['ip']):  # so I convert IP/nm to a Network to be able to use 'in' for checking
                # no link (connected device)
                if data['connected'] is None:
                    print(f'Error - interface link down on {name}')
                    return
                # there is link, try to ping
                if 'device' in data['connected']:
                    print(f'Pinging {ip}...')
                    for n in range(ip_count):
                        # Pinging ourselves... is fast :)
                        if data['ip'] == ip:
                            print('!', end='')
                            continue
                        reply = data['connected']['device'].echo_reply(ip)  # call echo-reply with destination IP
                        if reply == "!":  # the other end sent back '!' which means destination IP is there
                            print("!", end='')
                            sleep(0.100)  # simulate network response time
                        else:             # the other end did not send '!' so there is a problem over there
                            print(".", end='')
                            sleep(1)      # simulate timeout :)
                    print()
                    return
        print(f'Error - no route to {ip}')
Пример #30
0
async def find_hosts(redis: Redis, network: str) -> None:
    """ Scan the network to detect live hosts
    """
    async def is_alive(host: str) -> Union[None, str]:
        try:
            await ping(dest_addr=host, timeout=10)
        except TimeoutError:
            return None
        else:
            return host

    tasks: List = []
    for host in Network(network):
        tasks.append(asyncio.ensure_future(is_alive(str(host))))

    hosts = await asyncio.gather(*tasks)
    hosts = list(filter(None, hosts))

    await save_hosts(redis, hosts, expire=900)
    def add_network_cidr_mapping(self, network_config):
        """
        Method calculates and adds a CloudFormation mapping that is used to set VPC and Subnet CIDR blocks.
        Calculated based on CIDR block sizes and additionally checks to ensure all network segments
        fit inside of the specified overall VPC CIDR.
        @param network_config [dict] dictionary of values containing data for creating
        """
        az_count = int(network_config.get('az_count', '2'))
        network_cidr_base = str(
            network_config.get('network_cidr_base', '172.16.0.0'))
        network_cidr_size = str(network_config.get('network_cidr_size', '20'))
        first_network_address_block = str(
            network_config.get('first_network_address_block',
                               network_cidr_base))

        ret_val = {}
        base_cidr = network_cidr_base + '/' + network_cidr_size
        cidr_info = Network(base_cidr)
        ret_val['vpcBase'] = {'cidr': base_cidr}
        current_base_address = first_network_address_block

        subnet_config = self._get_subnet_config_w_cidr(network_config)
        subnet_config = self._subnet_configs = list(subnet_config)

        for index, subnet_config in enumerate(subnet_config):
            subnet_type = subnet_config.get('type', 'private')
            subnet_size = subnet_config.get('size', '22')
            subnet_name = subnet_config.get('name', 'subnet')
            subnet_az = subnet_config.get('AZ', '-1')
            subnet_cidr = subnet_config.get('cidr', 'ERROR')
            az_key = 'AZ{}'.format(subnet_az)

            # TODO: check for subnet collisions

            if az_key not in ret_val:
                ret_val[az_key] = dict()
            if subnet_name not in ret_val[az_key]:
                ret_val[az_key][subnet_name] = dict()
            ret_val[az_key][subnet_name] = subnet_cidr

        return self.add_mapping('networkAddresses', ret_val)
Пример #32
0
    def search_by_ip(self, ip):

        address_objects = []
        search_objects = []

        if "\"" not in ip:
            # find networks containing the search
            for line in self.config.get_filtered_lines(
                    "address", ["/"],
                [ip, "/32", "description", "address-set"]):
                m = re.search('address (.*) (.*)', line)
                network = m.group(2)
                if m:
                    if ip in Network(network):
                        address_objects.append(m.group(1))
                        search_objects.append(m.group(1))
        else:
            ip = ip.strip("\"")

        if "/" not in ip:
            ip += "/32"

        for line in self.config.get_filtered_lines("address", [self.lpad(ip)],
                                                   ["address-set"]):
            m = re.search('address (.+?) ', line)
            if m:
                address_objects.append(m.group(1))
                search_objects.append(m.group(1))

        for a in address_objects:
            for line in self.config.get_filtered_lines("address",
                                                       [self.lpad(a)],
                                                       ["global address "]):
                m = re.search('address-set (.+?) ', line)
                if m:
                    search_objects.append(m.group(1))

        return self.search(self.get_policies_for_search_terms(search_objects))
Пример #33
0
 def fqdn(self, ip):
     ip = Network(ip)
     prefix = self.prefixes().filter(first_ip_dec__lte=ip.ip, last_ip_dec__gte=ip.ip, size__gte=ip.size()).last()
     return prefix.fqdn() if prefix else None
Пример #34
0
def main():
    parser = OptionParser()
    parser.add_option("-m", "--multithread", dest="multithread", help="number of threads for concurrency, default is 10")
    parser.add_option("-t", "--target", dest="target", help="Target ip in network to scan -t 192.168.192.0.10/24")
    parser.add_option("-s", "--sleeping", dest="sleeping", help="Seconds to sleep after one cycle, default is 1")
    parser.add_option("-f", "--filename", dest="filename", help="the file to record recent counting result")
    parser.add_option("-j", "--maxjump", dest="maxjump", help="if more than MAXJUMP continuous IPv4 addresses not respond, stop")
    parser.add_option("-w", "--timeout", dest="timeout", help="Ping timeout, default: 2")
    parser.add_option("-c", "--count", dest="count", help="Stop after sending <count> requests to host, default: 1")
    parser.add_option("-i", "--interval", dest="interval", help="Wait <interval> seconds between sending packet, default: 0.2")
    (options, args) = parser.parse_args()

    if not options.target or not '/' in options.target:
        print "please specify a target: -t 192.168.0.10/24"
        print "use -h to view helping text"
        return

    interval = (options.interval if options.interval else '0.1')
    timeout = (options.timeout if options.timeout else '1')
    count = (options.count if options.count else '1')
    multithread = (int(options.multithread) if options.multithread else 10)
    sleeping = (int(options.sleeping) if options.sleeping else 1)
    target = options.target
    filename = (options.filename if options.filename else './subnet_count')
    maxjump = (int(options.maxjump) if options.maxjump else 256*256*256*256)
    
    net = Network(target)
    DEVNULL = open(os.devnull, 'w')
    
    commands.getstatusoutput("echo "+str(0)+" > "+filename)
    
    global alive_num
    global last_alive_index

    while(1):
        alive_num = 0
        last_alive_index = 0
        index     = 0
        thread_pool = []

        need_to_ping = Network(str(net.host_first()) + '/' + target.split('/')[1])

        for ip in need_to_ping:
            index += 1
            if(index-last_alive_index > maxjump):
                break;
            t = PingOne(interval,timeout,count,ip,index,DEVNULL)
            thread_pool.append(t)
            if( index > 0 and index % multithread == 0):
                for tt in thread_pool:
                    tt.start()
                for tt in thread_pool:
                    tt.join()
                thread_pool[:] = []
        # last turn
        if thread_pool:
            for tt in thread_pool:
                tt.start()
            for tt in thread_pool:
                tt.join()
        thread_pool[:] = []
        commands.getstatusoutput("echo "+str(alive_num)+" > "+filename)
        print "find "+str(alive_num)+" alive ipv4 addresses"
        time.sleep(sleeping)
Пример #35
0
        'is_hosting_provider',
        'is_public_proxy',
        'is_tor_exit_node',
    )
)
i = 0
with open('imp.csv', 'r') as raw_db:
    raw_db.readline()
    for raw_row in csv.reader(raw_db, delimiter=','):
        impression_ip = raw_row[1]

        with open(
            'GeoIP2-Anonymous-IP-Blocks-IPv4.csv', 'r'
        ) as anon_db:
            anon_db.readline()
            for anon_row in csv.reader(
                anon_db, delimiter=','
            ):
                anon_row = [
                    '0' if x == '' else x for x in anon_row
                ]  # fill empty row with 0
                anonynous_ip = anon_row[0]
                if impression_ip in Network(anonynous_ip):
                    write_find(raw_row, anon_row)
                    break

        i += 1
        if i > COUNTER:
            out.close()
            break
Пример #36
0
    def save(self, recursion=True, user=None, *args, **kwargs):
        self.full_clean()
        network = Network(str(self.prefix))
        self.size = network.size()
        self.first_ip_dec = network.ip
        self.last_ip_dec = self.first_ip_dec + long(self.size) - 1
        self.sequence_number = self.first_ip_dec + self.length() * 0.01
        self.parent = self.find_parent()

        if self.size == 1:
            self.domain = ''

        old_data = None
        message = None

        if user:
            if self.id:
                old_data = {
                    'prefix': self.prefix,
                    'description': self.description,
                    'status': self.status,
                    'domain': self.domain,
                    'host_name': self.host_name,
                }
            else:
                message = u'User {user} ({email}) create prefix {prefix}. Status: {status}.'.format(
                    user=user.profile.get_short_name(), email=user.email, prefix=self.__str__(), status=self.status)
                if self.description:
                    message += u' Description: {0}.'.format(self.description)
                if self.domain:
                    message += u' Domain: {0}.'.format(self.domain)
                if self.host_name:
                    message += u' Hostname: {0}.'.format(self.host_name)

        super(Prefix4, self).save(*args, **kwargs)

        if user:
            from www.models import Journal
            from www.constatnts import JL_INFO

            if old_data:
                message = u'User {user} ({email}) updated prefix {prefix}.'.format(user=user.profile.get_short_name(),
                                                                                   email=user.email,
                                                                                   prefix=self.__str__())
                if self.status != old_data[u'status']:
                    message += u' Status was changed from "{0}" to "{1}".'.format(old_data['status'], self.status)
                if self.description != old_data[u'description']:
                    message += u' New description: "{0}".'.format(self.description)
                if self.domain != old_data[u'domain']:
                    message += u' Domain was changed from "{0}" to "{1}".'.format(old_data['domain'], self.domain)
                if self.host_name != old_data[u'host_name']:
                    message += u' Hostname was changed from "{0}" to "{1}".'.format(old_data['host_name'],
                                                                                    self.host_name)
            Journal.objects.create(level=JL_INFO, message=message, objects=[user, self, ])

        if recursion:
            for p in self.prefixes_lower():
                print 'Check {0}'.format(p)
                print p.find_parent()
                print p.parent
                if p.find_parent() != p.parent:
                    p.save(recursion=False)
Пример #37
0
 def test_ipv6_2(self):
     net = Network('::42', 64)
     self.assertTrue(str(net) == '0000:0000:0000:0000:0000:0000:0000:0042/64')
     self.assertTrue(str(net.to_compressed()) == '::42')
     self.assertTrue(str(net.to_ipv6().to_compressed()) == '::42')
     self.assertTrue(net.info() == 'IPV4COMP')
     self.assertTrue(net.subnet() == 64)
     self.assertTrue(net.size() == 1 << (128 - 64))
     self.assertTrue(int(net) == 0x42)
     self.assertTrue(net.hex().lower() == '00000000000000000000000000000042')
     self.assertTrue(str(net.netmask()) == 'ffff:ffff:ffff:ffff:0000:0000:0000:0000')
     self.assertTrue(net.version() == 6)
     self.assertTrue(str(net.network()) == '0000:0000:0000:0000:0000:0000:0000:0000')
     self.assertTrue(str(net.broadcast()) == '0000:0000:0000:0000:ffff:ffff:ffff:ffff')
     self.assertFalse('123:456::' in net)
     self.assertTrue('::aaaa:bbbb:cccc:dddd' in net)
     self.assertTrue('::dddd' in net)
     self.assertTrue('::1' in net)
     self.assertFalse('123::456' in net)
     self.assertTrue(str((net + 6).to_compressed()).lower() == '::48')
     self.assertTrue((net + 6) in net)
     self.assertTrue(str((net - 6).to_compressed()).lower() == '::3c')
     self.assertTrue((net - 6) in net)
Пример #38
0
 def test_ipv6_1(self):
     net = Network('123::', 128)
     self.assertTrue(
         str(net) == '0123:0000:0000:0000:0000:0000:0000:0000/128')
     self.assertTrue(str(net.to_compressed()) == '123::')
     self.assertTrue(str(net.to_ipv6().to_compressed()) == '123::')
     self.assertTrue(net.info() == 'UNKNOWN')
     self.assertTrue(net.subnet() == 128)
     self.assertTrue(net.size() == 1 << (128 - 128))
     self.assertTrue(int(net) == (0x123 << 112))
     self.assertTrue(
         net.hex().lower() == '01230000000000000000000000000000')
     self.assertTrue(
         str(net.netmask()) == 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
     self.assertTrue(net.version() == 6)
     self.assertTrue(
         str(net.network()) == '0123:0000:0000:0000:0000:0000:0000:0000')
     self.assertTrue(
         str(net.broadcast()) == '0123:0000:0000:0000:0000:0000:0000:0000')
     self.assertFalse('123:456::' in net)
     self.assertTrue('123::' in net)
     self.assertFalse('::1' in net)
     self.assertFalse('123::456' in net)
     self.assertTrue(str((net + 6).to_compressed()).lower() == '123::6')
     self.assertFalse((net + 6) in net)
     self.assertTrue(
         str((net - 6).to_compressed()).lower() ==
         '122:ffff:ffff:ffff:ffff:ffff:ffff:fffa')
     self.assertFalse((net - 6) in net)
Пример #39
0
                    hosts[ip] = domains
        except APIException as e:
            if e.code == 404:
                pass
            else:
                raise e
    for ip_address, domains in hosts.items():
        ip = IP(ip_address)
        ptr = ip.to_reverse()
        for domain in domains:
            if len(domain) > 0:
                resources[section_title].append((ip, ptr, domain.strip()))

    for subnet, domains in subnets.items():
        append = True
        net = Network(subnet)
        for ip_address in hosts:
            if IP(ip_address) in net:
                append = False
            if not append:
                break
        for subnet_2 in subnets:
            net_2 = Network(subnet_2)
            if net_2 in net and net_2.size() < net.size():
                append = False
            if not append:
                break
        if append:
            prefix, length = net.to_tuple()
            octets = int((length - length % 4) / 4)
            prefix = prefix.replace(':', '')[:octets]
Пример #40
0
 def test_ipv6_1(self):
     net = Network("123::", 128)
     self.assertTrue(str(net) == "0123:0000:0000:0000:0000:0000:0000:0000/128")
     self.assertTrue(str(net.to_compressed()) == "123::")
     self.assertTrue(str(net.to_ipv6().to_compressed()) == "123::")
     self.assertTrue(net.info() == "UNKNOWN")
     self.assertTrue(net.subnet() == 128)
     self.assertTrue(net.size() == 1 << (128 - 128))
     self.assertTrue(int(net) == (0x123 << 112))
     self.assertTrue(net.hex().lower() == "01230000000000000000000000000000")
     self.assertTrue(str(net.netmask()) == "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
     self.assertTrue(net.version() == 6)
     self.assertTrue(str(net.network()) == "0123:0000:0000:0000:0000:0000:0000:0000")
     self.assertTrue(str(net.broadcast()) == "0123:0000:0000:0000:0000:0000:0000:0000")
     self.assertFalse("123:456::" in net)
     self.assertTrue("123::" in net)
     self.assertFalse("::1" in net)
     self.assertFalse("123::456" in net)
     self.assertTrue(str((net + 6).to_compressed()).lower() == "123::6")
     self.assertFalse((net + 6) in net)
     self.assertTrue(str((net - 6).to_compressed()).lower() == "122:ffff:ffff:ffff:ffff:ffff:ffff:fffa")
     self.assertFalse((net - 6) in net)
Пример #41
0
 def network(self):
     return Network(self.ip)
Пример #42
0
 def test_ipv6_2(self):
     net = Network('::42', 64)
     self.assertTrue(
         str(net) == '0000:0000:0000:0000:0000:0000:0000:0042/64')
     self.assertTrue(str(net.to_compressed()) == '::42')
     self.assertTrue(str(net.to_ipv6().to_compressed()) == '::42')
     self.assertTrue(net.info() == 'IPV4COMP')
     self.assertTrue(net.subnet() == 64)
     self.assertTrue(net.size() == 1 << (128 - 64))
     self.assertTrue(int(net) == 0x42)
     self.assertTrue(
         net.hex().lower() == '00000000000000000000000000000042')
     self.assertTrue(
         str(net.netmask()) == 'ffff:ffff:ffff:ffff:0000:0000:0000:0000')
     self.assertTrue(net.version() == 6)
     self.assertTrue(
         str(net.network()) == '0000:0000:0000:0000:0000:0000:0000:0000')
     self.assertTrue(
         str(net.broadcast()) == '0000:0000:0000:0000:ffff:ffff:ffff:ffff')
     self.assertFalse('123:456::' in net)
     self.assertTrue('::aaaa:bbbb:cccc:dddd' in net)
     self.assertTrue('::dddd' in net)
     self.assertTrue('::1' in net)
     self.assertFalse('123::456' in net)
     self.assertTrue(str((net + 6).to_compressed()).lower() == '::48')
     self.assertTrue((net + 6) in net)
     self.assertTrue(str((net - 6).to_compressed()).lower() == '::3c')
     self.assertTrue((net - 6) in net)
Пример #43
0
 def test_ipv6_4(self):
     net = Network('2001:dead:beef:1:c01d:c01a::', 'ffff:ffff:ffff::')
     self.assertTrue(
         str(net) == '2001:dead:beef:0001:c01d:c01a:0000:0000/48')
     self.assertTrue(
         str(net.to_compressed()) == '2001:dead:beef:1:c01d:c01a::')
     self.assertTrue(
         str(net.to_ipv6().to_compressed()) ==
         '2001:dead:beef:1:c01d:c01a::')
     self.assertTrue(net.info() == 'UNKNOWN')
     self.assertTrue(net.subnet() == 48)
     self.assertTrue(net.size() == 1 << (128 - 48))
     self.assertTrue(int(net) == 0x2001deadbeef0001c01dc01a00000000)
     self.assertTrue(
         net.hex().lower() == '2001deadbeef0001c01dc01a00000000')
     self.assertTrue(
         str(net.netmask()) == 'ffff:ffff:ffff:0000:0000:0000:0000:0000')
     self.assertTrue(net.version() == 6)
     self.assertTrue(
         str(net.network()) == '2001:dead:beef:0000:0000:0000:0000:0000')
     self.assertTrue(
         str(net.broadcast()) == '2001:dead:beef:ffff:ffff:ffff:ffff:ffff')
     self.assertFalse('123:456::' in net)
     self.assertFalse('::aaaa:bbbb:cccc:dddd' in net)
     self.assertFalse('::dddd' in net)
     self.assertFalse('::1' in net)
     self.assertFalse('123::456' in net)
     self.assertTrue('2001:dead:beef:babe::1234' in net)
Пример #44
0
 def setUp(self):
     self.network = Network('192.168.11.0/255.255.255.0')
Пример #45
0
 def test_ipv4_3(self):
     net = Network('10.10.0.0/255.255.255.0')
     self.assertTrue(str(net) == '10.10.0.0/24')
     self.assertTrue(str(net.to_ipv6().to_compressed()) == '2002:a0a::')
     self.assertTrue(net.info() == 'PRIVATE')
     self.assertTrue(net.subnet() == 24)
     self.assertTrue(net.size() == 1 << (32 - 24))
     self.assertTrue(int(net) == 0x0a0a0000)
     self.assertTrue(net.hex().lower() == '0a0a0000')
     self.assertTrue(str(net.netmask()) == '255.255.255.0')
     self.assertTrue(net.version() == 4)
     self.assertTrue(str(net.network()) == '10.10.0.0')
     self.assertTrue(str(net.broadcast()) == '10.10.0.255')
     self.assertFalse('192.168.0.1' in net)
     self.assertFalse('192.168.114.128' in net)
     self.assertFalse('10.0.0.1' in net)
     self.assertTrue('10.10.0.254' in net)
     self.assertTrue('10.10.0.100' in net)
Пример #46
0
 def test_ipv6_4(self):
     net = Network('2001:dead:beef:1:c01d:c01a::', 'ffff:ffff:ffff::')
     self.assertTrue(str(net) == '2001:dead:beef:0001:c01d:c01a:0000:0000/48')
     self.assertTrue(str(net.to_compressed()) == '2001:dead:beef:1:c01d:c01a::')
     self.assertTrue(str(net.to_ipv6().to_compressed()) == '2001:dead:beef:1:c01d:c01a::')
     self.assertTrue(net.info() == 'UNKNOWN')
     self.assertTrue(net.subnet() == 48)
     self.assertTrue(net.size() == 1 << (128 - 48))
     self.assertTrue(int(net) == 0x2001deadbeef0001c01dc01a00000000)
     self.assertTrue(net.hex().lower() == '2001deadbeef0001c01dc01a00000000')
     self.assertTrue(str(net.netmask()) == 'ffff:ffff:ffff:0000:0000:0000:0000:0000')
     self.assertTrue(net.version() == 6)
     self.assertTrue(str(net.network()) == '2001:dead:beef:0000:0000:0000:0000:0000')
     self.assertTrue(str(net.broadcast()) == '2001:dead:beef:ffff:ffff:ffff:ffff:ffff')
     self.assertFalse('123:456::' in net)
     self.assertFalse('::aaaa:bbbb:cccc:dddd' in net)
     self.assertFalse('::dddd' in net)
     self.assertFalse('::1' in net)
     self.assertFalse('123::456' in net)
     self.assertTrue('2001:dead:beef:babe::1234' in net)
    def add_network_cidr_mapping(self, network_config):
        """
        Method calculates and adds a CloudFormation mapping that is used to set VPC and Subnet CIDR blocks.  Calculated based on CIDR block sizes and additionally checks to ensure all network segments fit inside of the specified overall VPC CIDR
        @param network_config [dict] dictionary of values containing data for creating
        """
        az_count = int(network_config.get('az_count', '2'))
        network_cidr_base = str(
            network_config.get('network_cidr_base', '172.16.0.0'))
        network_cidr_size = str(network_config.get('network_cidr_size', '20'))
        first_network_address_block = str(
            network_config.get('first_network_address_block',
                               network_cidr_base))

        ret_val = {}
        cidr_info = Network(network_cidr_base + '/' + network_cidr_size)
        base_cidr = cidr_info.network().to_tuple()[0] + '/' + str(
            cidr_info.to_tuple()[1])
        ret_val['vpcBase'] = {'cidr': base_cidr}
        current_base_address = first_network_address_block

        subnet_types = network_config.get('subnet_types',
                                          ['public', 'private'])

        for index in range(0, len(subnet_types)):
            subnet_type = subnet_types[index]
            subnet_size = network_config.get(subnet_type + '_subnet_size',
                                             '22')

            if index != 0:
                range_reset = Network(current_base_address + '/' +
                                      str(subnet_size))
                current_base_address = IP(
                    int(range_reset.host_last().hex(), 16) + 2).to_tuple()[0]

            for subnet_id in range(0, az_count):
                if not cidr_info.check_collision(current_base_address):
                    raise RuntimeError(
                        'Cannot continue creating network--current base address is outside the range of the master Cidr block. Found on pass '
                        + str(index + 1) + ' when creating ' + subnet_type +
                        ' subnet cidrs')
                ip_info = Network(current_base_address + '/' +
                                  str(subnet_size))
                range_info = ip_info.network().to_tuple()
                if 'subnet' + str(subnet_id) not in ret_val:
                    ret_val['subnet' + str(subnet_id)] = dict()
                ret_val['subnet' +
                        str(subnet_id)][subnet_type] = ip_info.network(
                        ).to_tuple()[0] + '/' + str(ip_info.to_tuple()[1])
                current_base_address = IP(
                    int(ip_info.host_last().hex(), 16) + 2).to_tuple()[0]

        return self.template.add_mapping('networkAddresses', ret_val)
Пример #48
0
 def test_ipv6_2(self):
     net = Network("::42", 64)
     self.assertTrue(str(net) == "0000:0000:0000:0000:0000:0000:0000:0042/64")
     self.assertTrue(str(net.to_compressed()) == "::42")
     self.assertTrue(str(net.to_ipv6().to_compressed()) == "::42")
     self.assertTrue(net.info() == "IPV4COMP")
     self.assertTrue(net.subnet() == 64)
     self.assertTrue(net.size() == 1 << (128 - 64))
     self.assertTrue(int(net) == 0x42)
     self.assertTrue(net.hex().lower() == "00000000000000000000000000000042")
     self.assertTrue(str(net.netmask()) == "ffff:ffff:ffff:ffff:0000:0000:0000:0000")
     self.assertTrue(net.version() == 6)
     self.assertTrue(str(net.network()) == "0000:0000:0000:0000:0000:0000:0000:0000")
     self.assertTrue(str(net.broadcast()) == "0000:0000:0000:0000:ffff:ffff:ffff:ffff")
     self.assertFalse("123:456::" in net)
     self.assertTrue("::aaaa:bbbb:cccc:dddd" in net)
     self.assertTrue("::dddd" in net)
     self.assertTrue("::1" in net)
     self.assertFalse("123::456" in net)
     self.assertTrue(str((net + 6).to_compressed()).lower() == "::48")
     self.assertTrue((net + 6) in net)
     self.assertTrue(str((net - 6).to_compressed()).lower() == "::3c")
     self.assertTrue((net - 6) in net)
Пример #49
0
 def test_ipv6_4(self):
     net = Network("2001:dead:beef:1:c01d:c01a::", "ffff:ffff:ffff::")
     self.assertTrue(str(net) == "2001:dead:beef:0001:c01d:c01a:0000:0000/48")
     self.assertTrue(str(net.to_compressed()) == "2001:dead:beef:1:c01d:c01a::")
     self.assertTrue(str(net.to_ipv6().to_compressed()) == "2001:dead:beef:1:c01d:c01a::")
     self.assertTrue(net.info() == "UNKNOWN")
     self.assertTrue(net.subnet() == 48)
     self.assertTrue(net.size() == 1 << (128 - 48))
     self.assertTrue(int(net) == 0x2001DEADBEEF0001C01DC01A00000000)
     self.assertTrue(net.hex().lower() == "2001deadbeef0001c01dc01a00000000")
     self.assertTrue(str(net.netmask()) == "ffff:ffff:ffff:0000:0000:0000:0000:0000")
     self.assertTrue(net.version() == 6)
     self.assertTrue(str(net.network()) == "2001:dead:beef:0000:0000:0000:0000:0000")
     self.assertTrue(str(net.broadcast()) == "2001:dead:beef:ffff:ffff:ffff:ffff:ffff")
     self.assertFalse("123:456::" in net)
     self.assertFalse("::aaaa:bbbb:cccc:dddd" in net)
     self.assertFalse("::dddd" in net)
     self.assertFalse("::1" in net)
     self.assertFalse("123::456" in net)
     self.assertTrue("2001:dead:beef:babe::1234" in net)
Пример #50
0
 def test_ipv6_1(self):
     net = Network('123::', 128)
     self.assertTrue(str(net) == '0123:0000:0000:0000:0000:0000:0000:0000/128')
     self.assertTrue(str(net.to_compressed()) == '123::')
     self.assertTrue(str(net.to_ipv6().to_compressed()) == '123::')
     self.assertTrue(net.info() == 'UNKNOWN')
     self.assertTrue(net.subnet() == 128)
     self.assertTrue(net.size() == 1 << (128 - 128))
     self.assertTrue(int(net) == (0x123<<112))
     self.assertTrue(net.hex().lower() == '01230000000000000000000000000000')
     self.assertTrue(str(net.netmask()) == 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
     self.assertTrue(net.version() == 6)
     self.assertTrue(str(net.network()) == '0123:0000:0000:0000:0000:0000:0000:0000')
     self.assertTrue(str(net.broadcast()) == '0123:0000:0000:0000:0000:0000:0000:0000')
     self.assertFalse('123:456::' in net)
     self.assertTrue('123::' in net)
     self.assertFalse('::1' in net)
     self.assertFalse('123::456' in net)
     self.assertTrue(str((net + 6).to_compressed()).lower() == '123::6')
     self.assertFalse((net + 6) in net)
     self.assertTrue(str((net - 6).to_compressed()).lower() == '122:ffff:ffff:ffff:ffff:ffff:ffff:fffa')
     self.assertFalse((net - 6) in net)
Пример #51
0
def cidr_to_dotted_mask(prefix):
    from ipcalc import Network

    return str(Network(prefix).netmask())
Пример #52
0
def is_subprefix(prefix, subprefix):
    from ipcalc import Network

    return subprefix in Network(prefix)
Пример #53
0
 def test_ipv4_1(self):
     net = Network('192.168.114.42', 23)
     self.assertTrue(str(net) == '192.168.114.42/23')
     self.assertTrue(
         str(net.to_ipv6().to_compressed()) == '2002:c0a8:722a::')
     self.assertTrue(net.info() == 'PRIVATE')
     self.assertTrue(net.subnet() == 23)
     self.assertTrue(net.size() == 1 << (32 - 23))
     self.assertTrue(int(net) == 0xc0a8722a)
     self.assertTrue(net.hex().lower() == 'c0a8722a')
     self.assertTrue(str(net.netmask()) == '255.255.254.0')
     self.assertTrue(net.version() == 4)
     self.assertTrue(str(net.network()) == '192.168.114.0')
     self.assertTrue(str(net.broadcast()) == '192.168.115.255')
     self.assertFalse('192.168.0.1' in net)
     self.assertTrue('192.168.114.128' in net)
     self.assertFalse('10.0.0.1' in net)
     self.assertTrue(str(net + 6) == '192.168.114.48/23')
     self.assertTrue((net + 6) in net)
     self.assertTrue(str(net - 6) == '192.168.114.36/23')
     self.assertTrue((net - 6) in net)