def testCache(self):
cac = RecordCache(0)
self.assertEqual(cac.lookup("abcdefghqqqq.com", Type.A, Class.IN), [])
test = ResourceRecord("blabla.com", Type.A, Class.IN, 0,
ARecordData("111.111.111.111"))
cac.add_record(test)
self.assertEqual(cac.lookup("blabla.com", Type.A, Class.IN), test)
def test_cache_lookup(self):
"""
Add a record to the cache and look it up
"""
rr = ResourceRecord("wiki.nl", Type.A, Class.IN, self.ttl, RecordData.create(Type.A, "192.168.123.456"))
cache = RecordCache()
cache.add_record(rr)
lookup_vals = cache.lookup("wiki.nl", Type.A, Class.IN)
self.assertEqual([rr], lookup_vals)
def test_cache_lookup(self):
"""
Add a record to the cache and look it up
"""
rr = ResourceRecord("wiki.nl", Type.A, Class.IN, self.ttl,
RecordData.create(Type.A, "192.168.123.456"))
cache = RecordCache()
cache.add_record(rr)
lookup_vals = cache.lookup("wiki.nl", Type.A, Class.IN)
self.assertEqual([rr], lookup_vals)
def test_TTL_expiration(self):
"""
cache a record, wait till ttl expires, see if record is removed from cache
"""
rr = ResourceRecord("wiki.nl", Type.A, Class.IN, self.ttl, RecordData.create(Type.A, "192.168.123.456"))
cache = RecordCache()
cache.add_record(rr)
time.sleep(rr.ttl)
lookup_vals = cache.lookup("wiki.nl", Type.A, Class.IN)
self.assertFalse(lookup_vals)
def test_expired_cache_entry(self):
cache = RecordCache(0)
record = ResourceRecord(
name=Name("bonobo.putin"),
type_=Type.A,
class_=Class.IN,
ttl=0,
rdata=ARecordData("1.0.0.1"),
)
cache.add_record(record)
self.assertEqual(cache.lookup(Name("bonobo.putin"), Type.A, Class.IN),
None)
def test_invalid_domain_from_cache(self):
cache = RecordCache(0)
record = ResourceRecord(
name=Name("bonobo.putin"),
type_=Type.A,
class_=Class.IN,
ttl=60,
rdata=ARecordData("1.0.0.1"),
)
cache.add_record(record)
self.assertEqual(cache.lookup(Name("bonobo.putin"), Type.A, Class.IN),
record)
def test_TTL_expiration(self):
"""
cache a record, wait till ttl expires, see if record is removed from cache
"""
rr = ResourceRecord("wiki.nl", Type.A, Class.IN, self.ttl,
RecordData.create(Type.A, "192.168.123.456"))
cache = RecordCache()
cache.add_record(rr)
time.sleep(rr.ttl)
lookup_vals = cache.lookup("wiki.nl", Type.A, Class.IN)
self.assertFalse(lookup_vals)
def test_ttl_overwrite(self):
cache = RecordCache(60)
record = ResourceRecord(
name=Name("bonobo.putin"),
type_=Type.A,
class_=Class.IN,
ttl=0,
rdata=ARecordData("1.0.0.1"),
)
cache.add_record(record)
cache_entry = cache.lookup(Name("bonobo.putin"), Type.A, Class.IN)
self.assertEqual(cache_entry, record)
self.assertEqual(cache_entry.ttl, 60)
def test_cache_disk_io(self):
"""
Add a record to the cache, write to disk, read from disk, do a lookup
"""
rr = ResourceRecord("wiki.nl", Type.A, Class.IN, self.ttl, RecordData.create(Type.A, "192.168.123.456"))
cache = RecordCache()
cache.write_cache_file() # overwrite the current cache file
# add rr to cache and write to disk
cache.add_record(rr)
cache.write_cache_file()
# read from disk again
new_cache = RecordCache()
new_cache.read_cache_file()
lookup_vals = new_cache.lookup("wiki.nl", Type.A, Class.IN)
self.assertEqual([rr], lookup_vals)
def test_cache_disk_io(self):
"""
Add a record to the cache, write to disk, read from disk, do a lookup
"""
rr = ResourceRecord("wiki.nl", Type.A, Class.IN, self.ttl,
RecordData.create(Type.A, "192.168.123.456"))
cache = RecordCache()
cache.write_cache_file() # overwrite the current cache file
# add rr to cache and write to disk
cache.add_record(rr)
cache.write_cache_file()
# read from disk again
new_cache = RecordCache()
new_cache.read_cache_file()
lookup_vals = new_cache.lookup("wiki.nl", Type.A, Class.IN)
self.assertEqual([rr], lookup_vals)
class Resolver:
"""DNS resolver"""
def __init__(self, timeout, caching, ttl):
"""Initialize the resolver
Args:
caching (bool): caching is enabled if True
ttl (int): ttl of cache entries (if > 0)
"""
self.cache = RecordCache(10000000)
self.timeout = timeout
self.caching = caching
self.ttl = ttl
self.hints = {
"a.root-servers.net": "198.41.0.4",
"b.root-servers.net": "192.228.79.201",
"c.root-servers.net": "192.33.4.12",
"d.root-servers.net": "199.7.91.13",
"e.root-servers.net": "192.203.230.10",
"f.root-servers.net": "192.5.5.241",
"g.root-servers.net": "192.112.36.4",
"h.root-servers.net": "128.63.2.53",
"i.root-servers.net": "192.36.148.17",
"j.root-servers.net": "192.58.128.30",
"k.root-servers.net": "193.0.14.129",
"l.root-servers.net": "199.7.83.42",
"m.root-servers.net": "202.12.27.33"
}
def gethostbyname(self, hostname):
"""Translate a host name to IPv4 address.
Currently this method contains an example. You will have to replace
this example with the algorithm described in section 5.3.3 in RFC 1034.
Args:
hostname (str): the hostname to resolve
Returns:
(str, [str], [str]): (hostname, aliaslist, ipaddrlist)
"""
#start with empty lists
aliaslist = []
ipaddrlist = []
#initiate with the list of hints to use.
servers = self.hints.copy()
#so hostname is not lost when we resolve a CNAME at some point.
domain = hostname
finished = False
#check cache of hostname is in the cache.
cache_entries = self.cache.lookup(hostname, Type.A,
Class.IN) + self.cache.lookup(
hostname, Type.CNAME, Class.IN)
if (len(cache_entries) > 0):
#TODO
pass
while (servers and not finished):
#take a server from the list of servers to ask for the domain we're looking for.
name, server = servers.popitem()
#if the server doesn't have an address, resolve this address first.
if (server == None):
a, b, c = self.gethostbyname(name)
if (len(c) > 0):
servers[name] = c[0]
server = c[0]
else:
continue
#check whether the name is in the cache.
cache_entries = self.cache.lookup(name, Type.A,
Class.IN) + self.cache.lookup(
name, Type.CNAME, Class.IN)
if (len(cache_entries) > 0):
for ce in cache_entries:
if ce.type_ == 1:
address = ans.rdata.to_dict()['address']
if (address not in ipaddrlist):
ipaddrlist.append(address)
if ce.type_ == 5:
domain = ans.to_dict()['rdata']['cname']
if domain not in aliaslist:
aliaslist.append(str(domain))
#send question to the server to see if it knows where we can find domain
try:
response = self.sendQuestion(domain, server)
except:
continue
#if the location is in the answers we're done.
for ans in response.answers:
if ans.type_ == 1:
address = ans.rdata.to_dict()['address']
if (address not in ipaddrlist):
ipaddrlist.append(address)
if (self.caching):
self.cache.add_record(ans)
if ans.type_ == 5:
domain = ans.to_dict()['rdata']['cname']
if domain not in aliaslist:
aliaslist.append(str(domain))
#add new servers we can ask for the location to our list of servers.
new_servers = self.getNewServers(response.authorities,
response.additionals)
#if we found a (list of) IP-address(es) we're done.
if (len(ipaddrlist) > 0):
finished = True
#combine old list of servers with new one.
servers = {**servers, **new_servers}
return hostname, aliaslist, ipaddrlist
'''Used to combine the suggested servers to check. '''
def getNewServers(self, authorities, additionals):
serverlist = {}
for b in authorities:
if (b.type_ == 6):
continue
serverlist.update({str(b.rdata.to_dict()['nsdname']): None})
for a in additionals:
if (str(a.name) == str(b.rdata.to_dict()['nsdname'])):
if (a.type_ == 1):
serverlist.update({
str(b.rdata.to_dict()['nsdname']):
a.rdata.to_dict()['address']
})
return serverlist
'''Used to handle the sending and receiving of requests/responses.'''
def sendQuestion(self, hostname, server):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(self.timeout)
# Create and send query
identifier = 9001 # placeholder
question = Question(Name(hostname), Type.A, Class.IN)
header = Header(identifier, 0, 1, 0, 0, 0)
header.qr = 0
header.opcode = 0
header.rd = 1
query = Message(header, [question])
sock.sendto(query.to_bytes(), (server, 53))
# Receive response
data = sock.recv(512)
response = Message.from_bytes(data)
sock.close()
return response
def gethostbyname(self, hostname, dnsserv='192.112.36.4'):
"""Translate a host name to IPv4 address.
Currently this method contains an example. You will have to replace
this example with the algorithm described in section 5.3.3 in RFC 1034.
Args:
hostname (str): the hostname to resolve
Returns:
(str, [str], [str]): (hostname, aliaslist, ipaddrlist)
"""
ipaddrlist = []
cnames = []
temp = []
if (self.caching):
rcache = RecordCache(self.ttl)
rcord = rcache.lookup(hostname, Type.ANY, Class.IN)
if (rcord):
for rec in rcord:
if rec.type_ == Type.A:
arec = rec.rdata
ipaddrlist.append(arec.address)
elif rec.type_ == Type.CNAME:
crec = rec.rdata
cnames.append(crec.cname)
if ipaddrlist:
return hostname, cnames, ipaddrlist
elif cnames:
return self.gethostbyname(cnames[0], dnsserv)
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(self.timeout)
# Create and send query
question = Question(Name(str(hostname)), Type.A, Class.IN)
header = Header(9001, 0, 1, 0, 0, 0)
header.qr = 0
header.opcode = 0
header.rd = 1
query = Message(header, [question])
sock.sendto(query.to_bytes(), (str(dnsserv), 53))
# Receive response
data = sock.recv(2048)
response = Message.from_bytes(data)
print("Number of answers: " + str(len(response.answers)))
print("Number of authorities: " + str(len(response.authorities)))
print("Number of additionals: " + str(len(response.additionals)))
# Get data
aliaslist = cnames
ipaddrlist = []
dnslist = []
while response.answers:
for answer in response.answers:
if answer.type_ == Type.A:
print("found A RR")
if (self.caching):
rcache.add_record(answer)
ipaddrlist.append(answer.rdata.address)
if answer.type_ == Type.CNAME:
aliaslist.append(answer.rdata.cname)
if answer.type_ == Type.NS:
dnslist.append(answer.rdata.nsdname)
if ipaddrlist:
return hostname, aliaslist, ipaddrlist
elif aliaslist:
question = Question(Name(aliaslist[0]), Type.A, Class.IN)
query = Message(header, [question])
sock.sendto(query.to_bytes(), (dnsserv, 53))
data = sock.recv(2048)
response = Message.from_bytes(data)
elif dnslist:
nsname = dnslist.pop()
maybe_dnsserv = self.getnsaddr(nsname, response.additionals)
if maybe_dnsserv:
dnsserv = maybe_dnsserv
else:
pass
sock.sendto(query.to_bytes(), (dnsserv, 53))
data = sock.recv(2048)
response = Message.from_bytes(data)
else:
break
if response.authorities:
for authority in response.authorities:
if authority.type_ != Type.NS:
pass
dnslist.append(authority.rdata.nsdname)
while dnslist:
nsname = dnslist.pop()
maybe_next_dnsserv = self.getnsaddr(nsname,
response.additionals)
if maybe_next_dnsserv:
next_dns_serv = maybe_next_dnsserv
else:
pass
(hname, aliasl, ipaddrl) = self.gethostbyname(hostname, nsname)
if ipaddrl:
return hname, aliasl, ipaddrl
class Resolver:
"""DNS resolver"""
def __init__(self, timeout, caching, ttl, sock=None, cache=None):
"""Initialize the resolver
Args:
caching (bool): caching is enabled if True
ttl (int): ttl of cache entries (if > 0)
"""
self.timeout = timeout
self.caching = caching
self.rc = cache
self.ttl = ttl
if self.rc == None:
self.rc = RecordCache(self.ttl)
self.zone = Zone()
self.sock = sock
if self.sock is None:
self.sock = SocketWrapper(53)
self.sock.start()
def _make_id(self):
gm = time.gmtime()
mss = str(time.time()).split(".")[1][0:3]
gms = str(gm.tm_sec)
id = int(gms + mss)
return id
def gethostbyname(self, hostname):
"""Translate a host name to IPv4 address.
Currently this method contains an example. You will have to replace
this example with the algorithm described in section 5.3.3 in RFC 1034.
Args:
hostname (str): the hostname to resolve
Returns:
(str, [str], [str]): (hostname, aliaslist, ipaddrlist)
"""
alias_list = []
a_list = []
slist = []
found = False
acs = self.getRecordsFromCache(hostname, Type.A, Class.IN)
if acs:
a_list += acs
return hostname, alias_list, a_list
nscs = self.matchByLabel(hostname, Type.NS, Class.IN)
for ns in nscs:
glue = self.getRecordsFromCache(str(ns.rdata.nsdname))
if glue:
slist += glue
else:
slist += [ns]
id = self._make_id()
# Create and send query
question = Question(Name(hostname), Type.A, Class.IN)
header = Header(id, 0, 1, 0, 0, 0)
header.qr = 0 # 0 for query
header.opcode = 0 # standad query
header.rd = 0 # not recursive
query = Message(header, [question])
self.zone.read_master_file('dns/root.zone')
sbelt = []
for root in list(self.zone.records.values()):
sbelt += [r for r in root if r.type_ == Type.A]
while not found:
if slist:
rr = slist.pop()
if rr.type_ == Type.A:
addr = rr.rdata.address
self.sock.send((query, addr, 53))
elif rr.type_ == Type.NS:
fqdn = str(rr.rdata.nsdname)
_, _, a_rrs = self.gethostbyname(fqdn)
slist += a_rrs
continue
elif rr.type_ == Type.CNAME:
fqdn = str(rr.rdata.cname)
_, cname_rrs, a_rrs = self.gethostbyname(fqdn)
a_list += a_rrs
alias_list += cname_rrs
break
elif sbelt:
rr = sbelt.pop()
addr = rr.rdata.address
self.sock.send((query, addr, 53))
else:
break
# Receive response
data = None
while not data:
data = self.sock.msgThere(id)
response, _ = data[0]
#response = Message.from_bytes(data)
for answer in response.answers:
if answer.type_ == Type.A:
self.addRecordToCache(answer)
a_list.append(answer)
found = True
if answer.type_ == Type.CNAME:
self.addRecordToCache(answer)
alias_list.append(answer)
slist += [answer]
continue
nss = []
for auth in response.authorities:
if auth.type_ == Type.NS:
nss.append(auth)
self.addRecordToCache(auth)
a_add = {}
for add in response.additionals:
if add.type_ == Type.A:
name = str(add.name)
a_add[name] = add
self.addRecordToCache(add)
for ns in nss:
name = str(ns.rdata.nsdname)
if name in a_add:
slist += [a_add[name]]
else:
slist += [ns]
return hostname, alias_list, a_list
def addRecordToCache(self, record):
if self.caching:
self.rc.add_record(record)
def getRecordsFromCache(self, dname, t=Type.A, c=Class.IN):
if self.caching:
return self.rc.lookup(dname, t, c)
else:
return []
def matchByLabel(self, dname, type_, class_):
if self.caching:
return self.rc.matchByLabel(dname, type_, class_)
else:
return []
def shutdown(self):
"""
to be used only when initialized for testing
:return:
"""
self.sock.shutdown()
class Server:
"""A recursive DNS server"""
def __init__(self, port, caching, ttl):
"""Initialize the server
Args:
port (int): port that server is listening on
caching (bool): server uses resolver with caching if true
ttl (int): ttl for records (if > 0) of cache
"""
self.caching = caching
self.ttl = ttl
self.port = port
self.done = False
self.zone = Zone()
self.zone.read_master_file('zone')
self.cache = RecordCache(ttl)
if self.caching:
self.cache.read_cache_file()
self.doLogging = True
def log(self, *args, end="\n"):
if self.doLogging:
print(*args, end=end)
def search_zone(self, question):
tests = str(question).split('.')
for i in range(len(tests)):
test = '.'.join(tests[i:])
if test == '':
test = '.'
r = self.zone.records.get(test, None)
if not r == None:
if test == str(question):
return True, r
return False, r
return False, []
def zone_resolution(self, questions):
for q in questions:
self.log("\tRESOLVING:", q.qname)
res, rlist = self.search_zone(q.qname)
answers = []
authorities = []
additionals = []
for r in rlist:
if r.type_ == Type.A and res:
answers.append(r)
if r.type_ == Type.NS:
res, a = self.search_zone(r.rdata.nsdname)
authorities.append(r)
if res:
additionals.append(a[0])
return answers, authorities, additionals
def check_cache(self, hostname):
iplist = self.cache.lookup(hostname, Type.A, Class.IN)
namelist = self.cache.lookup(hostname, Type.CNAME, Class.IN)
if not (iplist == [] and namelist == []):
iplist = [x.rdata.address for x in iplist]
namelist = [x.rdata.cname for x in namelist]
return True, iplist, namelist
return False, [], []
def consult_cache(self, questions):
answers = []
for q in questions:
res, iplist, namelist = self.check_cache(q.qname)
if res:
for ip in iplist:
answers.append(ResourceRecord(q.qname, Type.A, Class.IN, self.ttl, ARecordData(ip)))
for n in namelist:
answers.append(ResourceRecord(q.qname, Type.CNAME, Class.IN, self.ttl, CNAMERecordData(n)))
return answers
def build_message(self,id, rd, aa, rcode, questions, answers, authorities, additionals):
header = Header(id, 0, len(questions), len(answers), len(authorities), len(additionals))
header.qr = 1
header.opcode = 0
header.rd = rd
header.ra = 1
header.aa = aa
header.rcode = rcode
return Message(header, questions=questions, answers=answers, authorities=authorities, additionals=additionals)
def serve(self):
"""Start serving requests"""
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(("", self.port))
while not self.done:
data, address = sock.recvfrom(65565)
message = Message.from_bytes(data)
rd = message.header.rd
rcode = 0
aa = 1
self.log("REQUEST RECIEVED:", address)
answers, authorities, additionals = self.zone_resolution(message.questions)
if answers == []:
if authorities == [] and additionals == []:
self.log("\tZONE RESOLUTION FAILED")
answers = self.consult_cache(message.questions)
if answers == []:
self.log("\tCACHE LOOKUP FAILED")
rcode = 3
else:
aa = 0
if rcode == 3 and rd == 1:
rcode = 0
self.log("\tCALLING RESOLVER")
resolver = Resolver(5, True, 0)
resolver.rd = 0
resolver.rootip = "198.41.0.4"
for q in message.questions:
self.log("\t\tRESOLVING:", q.qname)
hostname, namelist, iplist = resolver.gethostbyname(str(q.qname))
if hostname == str(q.qname):
for ip in iplist:
answers.append(ResourceRecord(q.qname, Type.A, Class.IN, self.ttl, ARecordData(ip)))
for n in namelist:
answers.append(ResourceRecord(q.qname, Type.CNAME, Class.IN, self.ttl, CNAMERecordData(n)))
self.log("SENDING RESPONSE:", rcode, "\n")
mess = self.build_message(message.header.ident, rd, aa, rcode, message.questions, answers, authorities, additionals)
sock.sendto(mess.to_bytes(), address)
def shutdown(self):
"""Shut the server down"""
self.done = True
class Resolver:
"""DNS resolver"""
def __init__(self, timeout, caching, ttl, rootip="198.41.0.4"):
"""Initialize the resolver
Args:
caching (bool): caching is enabled if True
ttl (int): ttl of cache entries (if > 0)
"""
self.timeout = timeout
self.caching = caching
self.ttl = ttl
self.doLogging = False
self.rootip = rootip
self.rd = 0
if self.caching:
self.cache = RecordCache(ttl)
self.cache.read_cache_file()
def log(self, *args, end="\n"):
if self.doLogging:
print(*args, end=end)
def logHeader(self, header):
self.log("\tFLAGS", end="")
self.log(" QR", header.qr, end=";")
self.log(" OPCODE", header.opcode, end=";")
self.log(" AA", header.aa, end=";")
self.log(" TC", header.tc, end=";")
self.log(" RD", header.rd, end=";")
self.log(" RA", header.ra, end=";")
self.log(" Z", header.z, end=";")
self.log(" RCODE", header.rcode, end=";\n")
def check_cache(self, hostname):
iplist = self.cache.lookup(Name(hostname), Type.A, Class.IN)
namelist = self.cache.lookup(Name(hostname), Type.CNAME, Class.IN)
if not (iplist == [] and namelist == []):
iplist = [x.rdata.address for x in iplist]
namelist = [x.rdata.cname for x in namelist]
return True, iplist, namelist
hostname = hostname.split('.')
for i in range(len(hostname)):
test = '.'.join(hostname[i:])
namelist = self.cache.lookup(Name(test), Type.NS, Class.IN)
namelist = [x.rdata.nsdname for x in namelist]
if not namelist == []:
for x in namelist:
newips = self.cache.lookup(x, Type.A, Class.IN)
iplist.extend(newips)
iplist = [x.rdata.address for x in iplist]
return False, iplist, namelist
return False, [], []
def send_request(self, ip, name):
#create socket and request
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(self.timeout)
question = Question(name, Type.A, Class.IN)
header = Header(9001, 0, 1, 0, 0, 0)
header.qr = 0
header.opcode = 0
header.rd = self.rd
query = Message(header, [question])
sock.sendto(query.to_bytes(), (ip, 53))
# Receive response
data = sock.recv(512)
sock.close()
response = Message.from_bytes(data)
self.logHeader(response.header)
if self.caching:
for r in response.resources:
if r.type_ == Type.A or r.type_ == Type.CNAME or r.type_ == Type.NS:
self.cache.add_record(r)
return response.answers, response.authorities, response.additionals
def resolve_request(self, ip, hostname):
self.log("\nRESOLVING REQUEST", hostname, "at:", ip)
answers, authorities, additionals = self.send_request(ip, hostname)
namelist = []
ipaddrlist = []
if len(answers) != 0:
self.log("\n\tGOT RESPONSE")
for answer in answers:
if answer.type_ == Type.A:
ipaddrlist.append(answer.rdata.address)
self.log("\t\t", answer.type_, answer.rdata.address)
if answer.type_ == Type.CNAME:
namelist.append(hostname)
self.log("\t\t", answer.type_, answer.rdata.cname)
return True, ipaddrlist, namelist
else:
if len(additionals) != 0:
self.log("\n\tGOT ADDITIONALS")
for answer in additionals:
if answer.type_ == Type.A:
ipaddrlist.append(answer.rdata.address)
self.log('\t\t', answer.type_, answer.rdata.address)
if len(authorities) != 0:
self.log("\n\tGOT AUTHORITIES")
for answer in authorities:
if answer.type_ == Type.NS:
namelist.append(answer.rdata.nsdname)
self.log('\t\t', answer.type_, answer.rdata.nsdname)
return False, ipaddrlist, namelist
def gethostbyname(self, hostname):
"""Translate a host name to IPv4 address.
Currently this method contains an example. You will have to replace
this example with the algorithm described in section 5.3.3 in RFC 1034.
Args:
hostname (str): the hostname to resolve
Returns:
(str, [str], [str]): (hostname, aliaslist, ipaddrlist)
"""
self.log("NEW QUERY:", hostname)
serveriplist = [self.rootip]
if self.caching:
res, iplist, namelist = self.check_cache(hostname)
if not (iplist == [] and namelist == []):
self.log("CACHE HIT")
if res:
return hostname, namelist, iplist
else:
serveriplist = iplist
while len(serveriplist) != 0:
res, iplist, namelist = self.resolve_request(serveriplist[0], Name(hostname))
if res:
self.log("END OF QUERY:", hostname)
if self.caching:
self.cache.write_cache_file()
return hostname, namelist, iplist
elif len(iplist) == 0 and not len(namelist) == 0:
newlist = []
for x in namelist:
newhostname, newaliases, newips= self.gethostbyname(str(x))
newlist.extend(newips)
newlist.extend(serveriplist)
serveriplist = newlist
else:
iplist.extend(serveriplist[1:])
serveriplist = iplist
self.log("FAILURE")
return hostname, [], []
return hostname, [], []
class Resolver(object):
""" DNS resolver """
def __init__(self, timeout, caching, ttl, nameservers=[], use_rs=True):
""" Initialize the resolver
Args:
caching (bool): caching is enabled if True
ttl (int): ttl of cache entries (if > 0)
"""
self.timeout = timeout
self.caching = caching
self.ttl = ttl if ttl > 0 else 0 #Deze check is niet nodig voor de resolver gemaakt via de server, maar wel voor de resolver gemaakt door de client
if caching:
self.cache = RecordCache()
self.nameservers = nameservers
if use_rs:
self.nameservers += dns.consts.ROOT_SERVERS
def is_valid_hostname(self, hostname):
""" Check if hostname could be a valid hostname
Args:
hostname (str): the hostname that is to be checked
Returns:
boolean indiciting if hostname could be valid
"""
valid_hostnames = "^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$"
return re.match(valid_hostnames, hostname)
def save_cache(self):
""" Save the cache if appropriate """
if self.caching:
if self.cache is not None:
self.cache.write_cache_file()
def ask_server(self, query, server):
""" Send query to a server
Args:
query (Message): the query that is to be sent
server (str): IP address of the server that the query must be sent to
Returns:
responses ([Message]): the responses received converted to Messages
"""
response = None
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(self.timeout)
try:
sock.sendto(query.to_bytes(), (server, 53))
data = sock.recv(1024)
response = dns.message.Message.from_bytes(data)
if response.header.ident != query.header.ident:
return None
if self.caching:
for record in response.additionals + response.answers + response.authorities:
if record.type_ == Type.A or record.type_ == Type.CNAME:
record.ttl = self.ttl
record.timestamp = int(time.time())
self.cache.add_record(record)
except socket.timeout:
pass
return response
def gethostbyname(self, hostname):
""" Resolve hostname to an IP address
Args:
hostname (str): the FQDN that we want to resolve
Returns:
hostname (str): the FQDN that we want to resolve,
aliaslist ([str]): list of aliases of the hostname,
ipaddrlist ([str]): list of IP addresses of the hostname
"""
print("==GETHOSTNAME START=================")
aliaslist = []
ipaddrlist = []
#Check if the hostname is valid
valid = self.is_valid_hostname(hostname)
if not valid:
return hostname, [], []
#Check if the information is in the cache
if self.caching:
for alias in self.cache.lookup(hostname, Type.CNAME, Class.IN):
aliaslist.append(alias.rdata.data)
for address in self.cache.lookup(hostname, Type.A, Class.IN):
ipaddrlist.append(address.rdata.data)
if ipaddrlist:
print("We found an address in the cache!")
return hostname, aliaslist, ipaddrlist
#Do the recursive algorithm
hints = self.nameservers
while hints:
#Get the server to ask
hint = hints[0]
hints = hints[1:]
#Build the query to send to that server
identifier = randint(0, 65535)
question = dns.message.Question(hostname, Type.A, Class.IN)
header = dns.message.Header(identifier, 0, 1, 0, 0, 0)
header.qr = 0
header.opcode = 0
header.rd = 0
query = dns.message.Message(header, [question])
#Try to get a response
response = self.ask_server(query, hint)
if response == None:#We didn't get a response for this server, so check the next one
print("Server at " + hint + " did not respond.")
continue
#Analyze the response
for answer in response.answers + response.additionals:#First get the aliases
if answer.type_ == Type.CNAME and answer.rdata.data not in aliases:
aliaslist.append(answer.rdata.data)
for answer in response.answers:#Then try to get an address
if answer.type_ == Type.A and (answer.name == hostname or answer.name in aliaslist):
ipaddrlist.append(answer.rdata.data)
if ipaddrlist != []:
print("We found an address using the recursive search!")
return hostname, aliaslist, ipaddrlist
else:
for nameserver in response.authorities:
if nameserver.type_ == Type.NS:#Do a lookup for that ns?
#print(nameserver.rdata.data)
if self.caching:
self.cache.add_record(nameserver)
hints = [nameserver.rdata.data] + hints
print("Recursive search for " + hostname + " was a total failure")
return hostname, [], []