def test_get_asn_dns(self):
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.get_asn_dns(), dict)
except (ASNLookupError, ASNRegistryError):
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
def test_get_asn_dns(self):
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.get_asn_dns(), list)
except ASNLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
result.dns_zone = 'a'
self.assertRaises(ASNLookupError, result.get_asn_dns)
def test_get_asn_verbose_dns(self):
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.get_asn_verbose_dns(asn='15169'), str)
except ASNLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
self.assertRaises(ASNLookupError, result.get_asn_verbose_dns, **dict(
asn='a'
))
def test_get_asn_http(self):
data = {
'nets': {
'net': {
'orgRef': {
'@handle': 'APNIC'
}
}
}
}
result = Net('1.2.3.4')
try:
self.assertIsInstance(result.get_asn_http(result=data), dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data['nets']['net']['orgRef']['@handle'] = 'RIPE'
try:
self.assertIsInstance(result.get_asn_http(result=data), dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data['nets']['net']['orgRef']['@handle'] = 'DNIC'
try:
self.assertIsInstance(result.get_asn_http(result=data), dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data['nets']['net']['orgRef']['@handle'] = 'INVALID'
try:
self.assertRaises(ASNRegistryError, result.get_asn_http,
result=data)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data = ''
try:
self.assertIsInstance(result.get_asn_http(result=data), dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
def test_get_asn_whois(self):
data = ('15169 | 74.125.225.229 | 74.125.225.0/24 | US | arin'
' | 2007-03-13')
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.get_asn_whois(result=data), dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data = ('15169 | 74.125.225.229 | 74.125.225.0/24 | US | rdm'
' | 2007-03-13')
result = Net('74.125.225.229')
self.assertRaises(ASNRegistryError, result.get_asn_whois, 3, data)
def test_get_asn_dns(self):
data = ['"15169 ', ' 74.125.225.0/24 ', ' US ', ' arin ',
' 2007-03-13"']
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.get_asn_dns(result=data), dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data = ['"15169 ', ' 74.125.225.0/24 ', ' US ', ' random ',
' 2007-03-13"']
result = Net('74.125.225.229')
self.assertRaises(ASNRegistryError, result.get_asn_dns, data)
data = []
result = Net('74.125.225.229')
self.assertRaises(ASNLookupError, result.get_asn_dns, data)
def test_get_nets_other(self):
net = Net('210.107.73.73')
obj = Whois(net)
# No exception raised, but should provide code coverage for inetnum
# invalid IP ValueError.
multi_net_response = (
'\ninetnum: 210.107.0.0 - 210.107.127.256\n'
'\n')
obj.get_nets_other(multi_net_response)
def test_get_host(self):
ips = [
'74.125.225.229', # ARIN
'2001:4860:4860::8888'
]
for ip in ips:
result = Net(ip)
try:
self.assertIsInstance(result.get_host(0), tuple)
except HostLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
result = Net('74.125.225.229', 0)
self.assertRaises(HostLookupError, result.get_host, **dict(
retry_count=1))
def test_get_whois(self):
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.get_whois(), str)
except WhoisLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
self.assertRaises(WhoisLookupError, result.get_whois, **dict(
retry_count=0, server='arin.net'))
self.assertRaises(BlacklistError, result.get_whois, **dict(
server='whois.arin.net', extra_blacklist=['whois.arin.net']))
result = Net(address='74.125.225.229', timeout=0)
self.assertRaises(WhoisLookupError, result.get_whois, **dict(
retry_count=1))
def test_get_http_json(self):
from ipwhois.rdap import RIR_RDAP
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.get_http_json(
RIR_RDAP['arin']['ip_url'].format('74.125.225.229')), dict)
except HTTPLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
self.assertRaises(HTTPLookupError, result.get_http_json, **dict(
url='http://255.255.255.255', retry_count=1))
result = Net(address='74.125.225.229', timeout=0)
url = RIR_RDAP['arin']['ip_url'].format('74.125.225.229')
self.assertRaises(HTTPLookupError, result.get_http_json, **dict(
url=url, retry_count=0))
def test_get_http_json(self):
from ipwhois.rdap import RIR_RDAP
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.get_http_json(
RIR_RDAP['arin']['ip_url'].format('74.125.225.229')), dict)
except HTTPLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
self.assertRaises(HTTPLookupError, result.get_http_json, **dict(
url='http://255.255.255.255', retry_count=1))
result = Net(address='74.125.225.229', timeout=0)
url = RIR_RDAP['arin']['ip_url'].format('74.125.225.229')
self.assertRaises(HTTPLookupError, result.get_http_json, **dict(
url=url, retry_count=0))
def test_lookup_asn(self):
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.lookup_asn(), tuple)
except (HTTPLookupError, ASNRegistryError):
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
result = Net(address='74.125.225.229', timeout=0,
allow_permutations=False)
self.assertRaises(ASNRegistryError, result.lookup_asn)
result = Net(address='74.125.225.229', timeout=0,
allow_permutations=True)
self.assertRaises(HTTPLookupError, result.lookup_asn, **dict(
asn_alts=['http']
))
def test_get_whois(self):
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.get_whois(), str)
except WhoisLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
self.assertRaises(WhoisLookupError, result.get_whois, **dict(
retry_count=0, server='arin.net'))
self.assertRaises(BlacklistError, result.get_whois, **dict(
server='whois.arin.net', extra_blacklist=['whois.arin.net']))
result = Net(address='74.125.225.229', timeout=0)
self.assertRaises(WhoisLookupError, result.get_whois, **dict(
retry_count=1))
def test__get_nets_lacnic(self):
net = Net('200.57.141.161')
obj = Whois(net)
# No exception raised, but should provide code coverage for inetnum
# invalid IP ValueError.
multi_net_response = (
'\ninetnum: 200.57.256/19\r\n'
'\n'
)
obj._get_nets_lacnic(multi_net_response)
def locate_asn_info(ip):
"""
@IP: 147.229.2.90
"""
try:
net = Net(ip)
ipasn = IPASN(net)
results = ipasn.lookup()
except Exception:
return None
else:
return results
def test_get_asn_origin_whois(self):
# IP doesn't matter here
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.get_asn_origin_whois(asn='AS15169'),
str)
except WhoisLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
self.assertRaises(
WhoisLookupError, result.get_asn_origin_whois,
**dict(asn='AS15169', retry_count=0, server='radb.net'))
# IP doesn't matter here
result = Net(address='74.125.225.229', timeout=0)
self.assertRaises(WhoisLookupError, result.get_asn_origin_whois,
**dict(asn='AS15169', retry_count=1))
def test_get_asn_origin_whois(self):
# IP doesn't matter here
result = Net('74.125.225.229')
try:
self.assertIsInstance(result.get_asn_origin_whois(
asn='AS15169'), str)
except WhoisLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
self.assertRaises(WhoisLookupError, result.get_asn_origin_whois,
**dict(asn='AS15169', retry_count=0,
server='radb.net'))
# IP doesn't matter here
result = Net(address='74.125.225.229', timeout=0)
self.assertRaises(WhoisLookupError, result.get_asn_origin_whois,
**dict(asn='AS15169', retry_count=1))
def test_lookup_asn(self):
net = Net('74.125.225.229')
ipasn = IPASN(net)
try:
self.assertIsInstance(ipasn.lookup(), dict)
except HTTPLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
def test_get_nets_jpnic(self):
net = Net('133.1.2.5')
obj = NIRWhois(net)
# No exception raised, but should provide code coverage for multiple
# network scenarios and CIDR invalid IP ValueError.
multi_net_response = ('a. [Network Number] asd>133.1.0.0/16</A>'
'a. [Network Number] asd>133.1.0.0/24</A>')
obj.get_nets_jpnic(multi_net_response)
self.assertFalse(
obj.get_nets_jpnic('a. [Network Number] asd>asd/16</A>'))
def test_get_http_raw(self):
from ipwhois.nir import NIR_WHOIS
# GET
result = Net('133.1.2.5')
try:
self.assertIsInstance(result.get_http_raw(
NIR_WHOIS['jpnic']['url'].format('133.1.2.5')), str)
except HTTPLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
# POST
result = Net('115.1.2.3')
try:
self.assertIsInstance(result.get_http_raw(
url=NIR_WHOIS['krnic']['url'].format('115.1.2.3'),
request_type=NIR_WHOIS['krnic']['request_type'],
form_data={
NIR_WHOIS['krnic']['form_data_ip_field']: '115.1.2.3'
}
), str)
except HTTPLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
self.assertRaises(HTTPLookupError, result.get_http_raw, **dict(
url='http://255.255.255.255', retry_count=1))
result = Net(address='133.1.2.5', timeout=0)
url = NIR_WHOIS['jpnic']['url'].format('133.1.2.5')
self.assertRaises(HTTPLookupError, result.get_http_raw, **dict(
url=url, retry_count=0))
def addressRegistry(self):
if self.results is None:
try:
ip = socket.gethostbyname(self.parseResults.hostname)
net = Net(ip)
obj = IPASN(net)
self.results = obj.lookup()
registry = self.results['asn_registry']
return registry
except:
return 0
else:
registry = self.results['asn_registry']
return registry
def addressLocation(self):
if self.results is None:
try:
ip = socket.gethostbyname(self.parseResults.hostname)
net = Net(ip)
obj = IPASN(net)
self.results = obj.lookup()
country = self.results['asn_country_code']
return country
except:
return 0
else:
country = self.results['asn_country_code']
return country
def GetASN(self, IPaddress):
'''Retrieve AS Number of an IP address'''
try:
if IPaddress:
net = Net(IPaddress)
obj = IPASN(net)
res = obj.lookup()
IPasn = json.dumps(res["asn"])
else:
IPasn = None
return IPasn
except:
err = sys.exc_info()
print("[!!!] Problem with NetInfo Class: " + str(err))
def lookup(self, ipaddr):
val = self._conn.get(ipaddr)
if val:
return json.loads(val)
try:
net = Net(ipaddr)
obj = IPASN(net)
result = obj.lookup()
except Exception as e:
result = {"asn":"private"}
self._conn.setnx(ipaddr, json.dumps(result))
return result
def test__get_nets_arin(self):
net = Net('74.125.225.229')
obj = Whois(net)
# No exception raised, but should provide code coverage for multiple
# network scenarios and CIDR invalid IP ValueError.
multi_net_response = (
'\n#\n\nNetRange: 74.125.0.0 - 74.125.255.255'
'\nCIDR: 74.125.0.0/16\nNetName: TEST'
'\nCIDR: 74.125.1.256/24\nNetName: TEST2'
'\nNetRange: 74.125.1.0 - 74.125.1.0'
'\n')
obj._get_nets_arin(multi_net_response)
def test_get_contact(self):
net = Net('115.1.2.3')
obj = NIRWhois(net)
contact_response = ('Name : IP Manager'
'Phone : +82-2-500-6630'
'E-Mail : [email protected]')
# No exception raised.
obj.get_contact(response=contact_response,
handle=None,
nir='krnic',
dt_format=NIR_WHOIS['krnic']['dt_format'])
def myfunc(self):
import pandas as pd
import csv
import sys
import numpy as np
from csv import DictReader
from datetime import datetime
import ipaddress
from aslookup import get_as_data
import pyasn
from ipwhois import IPWhois
import multiprocessing as mp
from joblib import Parallel, delayed
from tqdm import tqdm
import ipinfo
from ipwhois.net import Net
from ipwhois.asn import IPASN
with open(Output, "a", newline='') as out:
writer = csv.writer(out)
if self[3] in dict_from_csv.keys():
#pos=np.where(FamousDNS["ip"]==self[3])
#as_pub=FamousDNS.iloc[pos[0][0],0]
ASN_dest = dict_from_csv[self[3]]
Type = 'Public'
#writer.writerow((self['prb_id'],self['timestamp'],self['resultset.result.rt'],self['dst_addr'],self['country_code'],self['asn_v4'],ASN_dest,Type))
elif (ipaddress.ip_address(self[3]).is_private):
ASN_dest = self[6]
Type = 'Private'
#writer.writerow((self['prb_id'],self['timestamp'],self['resultset.result.rt'],self['dst_addr'],self['country_code'],self['asn_v4'],ASN_dest,Type))
else:
try:
net = Net(self[3])
obj = IPASN(net)
results = obj.lookup(retry_count=0, asn_methods=['whois'])
as_unkn = results['asn']
ASN_dest = as_unkn
#self['ASN_dest']= as_unkn
Type = 'UnknownPublic'
#print(self['Type'])
#writer.writerow((self['prb_id'],self['timestamp'],self['resultset.result.rt'],self['dst_addr'],self['country_code'],self['asn_v4'],self['ASN_dest'],self['Type']))
except:
asnn = float(self[6])
ASN_dest = asnn
Type = 'Private'
writer.writerow((self[0], self[1], self[2], self[3], self[5], self[6],
ASN_dest, Type))
out.close()
def test__parse_fields_http(self):
data = {'nets': {'net': {'orgRef': {'@handle': 'APNIC'}}}}
net = Net('1.2.3.4')
ipasn = IPASN(net)
try:
self.assertIsInstance(ipasn._parse_fields_http(response=data),
dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data['nets']['net']['orgRef']['@handle'] = 'RIPE'
try:
self.assertIsInstance(ipasn._parse_fields_http(response=data),
dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data['nets']['net']['orgRef']['@handle'] = 'DNIC'
try:
self.assertIsInstance(ipasn._parse_fields_http(response=data),
dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data['nets']['net']['orgRef']['@handle'] = 'INVALID'
try:
self.assertRaises(ASNRegistryError,
ipasn._parse_fields_http,
response=data)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data = ''
try:
self.assertIsInstance(ipasn._parse_fields_http(response=data),
dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
def get_cidr(ip, asn):
try:
x = []
cidr = ASNOrigin(Net(ip)).lookup(asn=str(asn),
retry_count=10,
asn_methods=['whois'])
if cidr and len(cidr['nets']) > 0:
for c in cidr['nets']:
x.append(c['cidr'])
return x
except ASNOriginLookupError:
pass
def test__TestIPASNLookup(self):
net = Net('74.125.225.229')
ipasn = IPASN(net)
try:
self.assertIsInstance(ipasn.lookup(inc_raw=True), dict)
except (HTTPLookupError, ASNRegistryError):
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
net = Net(address='74.125.225.229',
timeout=0,
allow_permutations=False)
ipasn = IPASN(net)
self.assertRaises(ASNRegistryError, ipasn.lookup)
net = Net(address='74.125.225.229', timeout=0, allow_permutations=True)
ipasn = IPASN(net)
self.assertRaises(HTTPLookupError, ipasn.lookup,
**dict(asn_alts=['http']))
def test__TestASNOriginLookup(self):
data_dir = path.abspath(path.join(path.dirname(__file__), '..'))
with io.open(str(data_dir) + '/asn.json', 'r') as \
data_file:
data = json.load(data_file)
# IP doesn't matter here
net = Net('74.125.225.229')
for key, val in data.items():
log.debug('Testing: {0} - {1}'.format(key, val['asn']))
obj = ASNOrigin(net)
try:
self.assertIsInstance(obj.lookup(asn=val['asn']), dict)
except WhoisLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
net = Net(address='74.125.225.229', timeout=0, allow_permutations=True)
asnorigin = ASNOrigin(net)
self.assertRaises(HTTPLookupError, asnorigin.lookup,
**dict(asn='15169', asn_alts=['http']))
def test_parse_fields_dns(self):
data = '"15169 | 74.125.225.0/24 | US | arin | 2007-03-13"'
net = Net('74.125.225.229')
ipasn = IPASN(net)
try:
self.assertIsInstance(ipasn.parse_fields_dns(data), dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data = '"15169 | 74.125.225.0/24 | US | random | 2007-03-13"'
self.assertRaises(ASNRegistryError, ipasn.parse_fields_dns, data)
data = ''
self.assertRaises(ASNParseError, ipasn.parse_fields_dns, data)
def dateRegistered(self):
if self.results is None:
try:
ip = socket.gethostbyname(self.parseResults.hostname)
net = Net(ip)
obj = IPASN(net)
self.results = obj.lookup()
today = datetime.today()
date_registered = datetime.strptime(self.results['asn_date'],
'%Y-%m-%d')
return (today - date_registered).days
except:
return 0
else:
today = datetime.today()
date_registered = datetime.strptime(self.results['asn_date'],
'%Y-%m-%d')
return (today - date_registered).days
def test__get_nets_krnic(self):
net = Net('115.1.2.3')
obj = NIRWhois(net)
# No exception raised, but should provide code coverage for multiple
# network scenarios and CIDR invalid IP ValueError.
multi_net_response = (
'IPv4 Address : 115.0.0.0 - 115.23.255.255 (/12+/13)'
'IPv4 Address : 115.1.2.0 - 115.1.2.63 (/26)')
obj.get_nets_krnic(multi_net_response)
# ip_network ValueError
self.assertFalse(
obj.get_nets_krnic('IPv4 Address : asd - asd (/12+/13)'))
# Expected IP range regex not found, but some value found
self.assertFalse(obj.get_nets_krnic('IPv4 Address : asd'))
def test_parse_fields_whois(self):
data = ('15169 | 74.125.225.229 | 74.125.225.0/24 | US | arin'
' | 2007-03-13 | GOOGLE - Google Inc., US')
net = Net('74.125.225.229')
ipasn = IPASN(net)
try:
self.assertIsInstance(ipasn.parse_fields_whois(data), dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
data = ('15169 | 74.125.225.229 | 74.125.225.0/24 | US | rdm'
' | 2007-03-13 | GOOGLE - Google Inc., US')
self.assertRaises(ASNRegistryError, ipasn.parse_fields_whois, data)
data = '15169 | 74.125.225.229 | 74.125.225.0/24 | US'
self.assertRaises(ASNParseError, ipasn.parse_fields_whois, data)
def crawling(self):
ip_list = self._get_ip_list()
ip_result = []
for ip in ip_list:
if ip:
net = Net(ip)
obj = IPASN(net)
result = {'ip': ip}
result.update(obj.lookup())
result['asn_date'] = datetime.strptime(result['asn_date'],
'%Y-%m-%d')
ip_result.append(result)
if len(ip_result) % 100 == 0:
self._output_database(ip_result)
ip_result = []
self._output_database(ip_result)
def test_get_http_raw(self):
from ipwhois.nir import NIR_WHOIS
# GET
result = Net('133.1.2.5')
try:
self.assertIsInstance(
result.get_http_raw(
NIR_WHOIS['jpnic']['url'].format('133.1.2.5')), str)
except HTTPLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
# POST
result = Net('115.1.2.3')
try:
self.assertIsInstance(
result.get_http_raw(
url=NIR_WHOIS['krnic']['url'].format('115.1.2.3'),
request_type=NIR_WHOIS['krnic']['request_type'],
form_data={
NIR_WHOIS['krnic']['form_data_ip_field']: '115.1.2.3'
}), str)
except HTTPLookupError:
pass
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
self.assertRaises(HTTPLookupError, result.get_http_raw,
**dict(url='http://255.255.255.255', retry_count=1))
result = Net(address='133.1.2.5', timeout=0)
url = NIR_WHOIS['jpnic']['url'].format('133.1.2.5')
self.assertRaises(HTTPLookupError, result.get_http_raw,
**dict(url=url, retry_count=0))
def test_lookup(self):
data_dir = path.dirname(__file__)
with io.open(str(data_dir) + '/jpnic.json', 'r') as data_jpnic:
data = json.load(data_jpnic)
with io.open(str(data_dir) + '/krnic.json', 'r') as data_krnic:
data.update(json.load(data_krnic))
for key, val in data.items():
log.debug('Testing: {0}'.format(key))
net = Net(key)
obj = NIRWhois(net)
self.assertRaises(
KeyError, obj.lookup,
**dict(nir=val['nir'], response=None, is_offline=True))
try:
self.assertIsInstance(
obj.lookup(nir=val['nir'],
response=val['response'],
is_offline=True,
inc_raw=True), dict)
self.assertIsInstance(
obj.lookup(nir=val['nir'], response=val['response']), dict)
except AssertionError as e:
raise e
except Exception as e:
self.fail('Unexpected exception raised: {0}'.format(e))
self.assertRaises(NetError, NIRWhois, 'a')
self.assertRaises(KeyError, obj.lookup)
self.assertRaises(KeyError, obj.lookup, **dict(nir='a'))
def run(hostname, list_of_NS, ipv6):
listASN = []
try:
for x in list_of_NS:
ip_address = helpers.getTheIPofAServer(x, ipv6,
DESCRIPTION())["result"]
if isinstance(
helpers.getTheIPofAServer(x, ipv6,
DESCRIPTION())["result"], bool):
return helpers.getTheIPofAServer(x, ipv6, DESCRIPTION())
# Getting IPs of nameservers
net = Net(ip_address)
obj = IPASN(net)
# Getting dictionary with AS info for specific IP
results = obj.lookup()
# Extracts only ASN from dictionary and adds them to a list
listASN.append(results.get('asn'))
except Exception as err:
return {
"description": DESCRIPTION(),
"result": False,
"details": str(err) + f": could not resolve IP of nameserver {x}"
}
# Checks if nameservers ar located in at least 2 different Autonomous Systems
if len(set(listASN)) < 2:
return {
"description": DESCRIPTION(),
"result": False,
"details":
"All nameservers are located in the same Autonomous System"
}
else:
return {
"description":
DESCRIPTION(),
"result":
True,
"details":
f"Nameserver are located at {len(set(listASN))} different Autonumous Systems"
}
def test_parse_fields(self):
net = Net('74.125.225.229')
obj = ASNOrigin(net)
# No exception raised, but should provide code coverage for if regex
# groups are messed up.
tmp_dict = ASN_ORIGIN_WHOIS['radb']['fields']
tmp_dict['route'] = r'(route):[^\S\n]+(?P<val1>.+?)\n'
obj.parse_fields(
response="\nroute: 66.249.64.0/20\n",
fields_dict=tmp_dict
)
obj.parse_fields(
response="\nchanged: [email protected] 20110301\n",
fields_dict=ASN_ORIGIN_WHOIS['radb']['fields']
)
multi_net_response = (
'\n\nroute: 66.249.64.0/20'
'\ndescr: Google'
'\norigin: AS15169'
'\nnotify: [email protected]'
'\nmnt-by: MAINT-AS15169'
'\nchanged: [email protected] 20110301'
'\nsource: RADB'
'\n\nroute: 66.249.80.0/20'
'\ndescr: Google'
'\norigin: AS15169'
'\nnotify: [email protected]'
'\nmnt-by: MAINT-AS15169'
'\nchanged: [email protected] 20110301'
'\nsource: RADB'
'\n\n'
)
obj.parse_fields(
response=multi_net_response,
fields_dict=ASN_ORIGIN_WHOIS['radb']['fields']
)
def test_parse_fields(self):
net = Net('133.1.2.5')
obj = NIRWhois(net)
# No exception raised, but should provide code coverage for if regex
# groups are messed up.
tmp_dict = NIR_WHOIS['jpnic']['fields']
tmp_dict['name'] = r'(NetName):[^\S\n]+(?P<val1>.+?)\n'
obj.parse_fields(response='\nNetName: TEST\n',
fields_dict=tmp_dict,
dt_format=NIR_WHOIS['jpnic']['dt_format'])
obj.parse_fields(response='\nUpdated: 2012-02-24\n',
fields_dict=NIR_WHOIS['jpnic']['fields'],
dt_format=NIR_WHOIS['jpnic']['dt_format'])
log.debug('Testing field parse error. This should be followed by a '
'debug log.')
obj.parse_fields(response='\nUpdated: 2012-02-244\n',
fields_dict=NIR_WHOIS['jpnic']['fields'],
dt_format=NIR_WHOIS['jpnic']['dt_format'])