def resolve(): """Resolve a hostname using the resolver """ parser = ArgumentParser(description="DNS Client") parser.add_argument("hostname", help="hostname to resolve") parser.add_argument("--timeout", metavar="time", type=int, default=5, help="resolver timeout") parser.add_argument("-c", "--caching", action="store_true", help="Enable caching") parser.add_argument("-t", "--ttl", metavar="time", type=int, default=0, help="TTL value of cached entries (if > 0)") args = parser.parse_args() s = SocketWrapper(53) s.start() rc = RecordCache(3600) resolver = Resolver(args.timeout, args.caching, args.ttl, s, rc) hostname, aliaslist, ipaddrlist = resolver.gethostbyname(args.hostname) s.shutdown() rc.write_cache_file() print(hostname) print([rr.rdata.address for rr in aliaslist]) print([rr.rdata.address for rr in ipaddrlist])
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 setUp(self): # put invalid record in cache file record_data = RecordData.create(Type.A, "192.168.123.456") self.rr = ResourceRecord("invalid.invalid", Type.A, Class.IN, 3, record_data) cache = RecordCache() cache.add_record(self.rr) cache.write_cache_file()
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_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_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_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_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_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 __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.catalog = Catalog() self.sock = SocketWrapper(self.port) self.sock.start() self.cache = RecordCache(self.ttl)
def __init__(self, caching, cache=None): """ Initialize the resolver Args: caching (bool): caching is enabled if True """ self.caching = caching if cache: self.CACHE = cache else: if self.caching: self.CACHE = RecordCache() else: self.CACHE = MockedCache() self.STYPE = Type.A self.SCLASS = Class.IN self.SLIST = [] self.SBELT = [('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', '198.97.190.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')] self.aliases = [] self.addresses = [] self.timeout = 3
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 __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 __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()
class Server: """A recursive DNS server""" """ FLAGS The DNS Name Server is aware of DNS flags, namely it should use its DNS Resolver only if recursion is enabled in the query. Moreover, if it is authoritative over the requested FQDN in the query, it should then send an authoritative response. """ 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.catalog = Catalog() self.sock = SocketWrapper(self.port) self.sock.start() self.cache = RecordCache(self.ttl) def serve(self): """Start serving requests""" while not self.done: data = None while not data: msgs = self.sock.msgThere(-1) for m in msgs: data, addr = m re = RequestHandler(data, addr, self.catalog, self.sock, self.caching, self.cache, self.ttl) re.start() def shutdown(self): """Shut the server down""" self.cache.write_cache_file() #just to be sure self.done = True self.sock.shutdown()
def test_no_cache_entry(self): cache = RecordCache(0) resolver = Resolver(5, cache) self.assertEqual( resolver.gethostbyname("google-public-dns-a.google.com"), ("google-public-dns-a.google.com", [], ["8.8.8.8"]), ) self.assertEqual( resolver.gethostbyname("google-public-dns-b.google.com"), ("google-public-dns-b.google.com", [], ["8.8.4.4"]), )
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 resolve(): """Resolve a hostname using the resolver """ parser = ArgumentParser(description="DNS Client") parser.add_argument("hostname", help="hostname to resolve") parser.add_argument("--timeout", metavar="time", type=int, default=5, help="resolver timeout") parser.add_argument("-c", "--caching", action="store_true", help="Enable caching") parser.add_argument("-t", "--ttl", metavar="time", type=int, default=0, help="TTL value of cached entries (if > 0)") args = parser.parse_args() cache = RecordCache(args.ttl) if args.caching: cache.read_cache_file() resolver = Resolver(args.timeout, cache) else: resolver = Resolver(args.timeout) hostname, aliaslist, ipaddrlist = resolver.gethostbyname(args.hostname) if args.caching: cache.write_cache_file() print(hostname) print(aliaslist) print(ipaddrlist)
def setUp(self): # put invalid record in cache file record_data = RecordData.create(Type.A, "192.168.123.456") self.rr = ResourceRecord("invalid.invalid", Type.A, Class.IN, 3, record_data) cache = RecordCache() cache.add_record(self.rr) cache.write_cache_file()
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 setUp(self): file = "testCache" with open(file, "w") as file_: file_.write("") RC = RecordCache(2, file) self.RC = RC self.r1 = ResourceRecord.from_dict({ "type": "A", "name": "dnsIsAwesome.com", "class": "IN", "ttl": 2, "rdata": { "address": "192.123.12.23" } }) RC.add_record(self.r1) RC.write_cache_file()
def run_server(): parser = ArgumentParser(description="DNS Server") parser.add_argument( "-c", "--caching", action="store_true", help="Enable caching", ) parser.add_argument( "-t", "--ttl", metavar="time", type=int, default=0, help="TTL value of cached entries (if > 0)", ) parser.add_argument( "-p", "--port", type=int, default=53, help="Port which server listens on", ) args = parser.parse_args() zone = Zone() zone.read_master_file("zone") Server.catalog.add_zone("gumpe.", zone) if args.caching: cache = RecordCache(args.ttl) cache.read_cache_file() Server.cache = cache server = Server(args.port) try: server.serve() except KeyboardInterrupt: server.shutdown() if args.caching: cache.write_cache_file()
def test_invalid_domain_from_cache(self): cache = RecordCache(0) resolver = Resolver(5, cache) cache.add_record( ResourceRecord( name=Name("bonobo.putin"), type_=Type.A, class_=Class.IN, ttl=60, rdata=ARecordData("1.0.0.1"), )) cache.add_record( ResourceRecord( name=Name("bonobo.putin"), type_=Type.CNAME, class_=Class.IN, ttl=60, rdata=CNAMERecordData(Name("putin.bonobo")), )) self.assertEqual(resolver.gethostbyname("bonobo.putin"), ("bonobo.putin", ["putin.bonobo."], ["1.0.0.1"]))
def test_expired_cache_entry(self): cache = RecordCache(0) resolver = Resolver(5, cache) cache.add_record( ResourceRecord( name=Name("hw.gumpe"), type_=Type.A, class_=Class.IN, ttl=0, rdata=ARecordData("1.0.0.2"), )) cache.add_record( ResourceRecord( name=Name("hw.gumpe"), type_=Type.CNAME, class_=Class.IN, ttl=0, rdata=CNAMERecordData(Name("gumpe.hw")), )) self.assertEqual(resolver.gethostbyname("hw.gumpe"), ("hw.gumpe", [], []))
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, [], []
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, 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: """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()
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 setUp(self): self.RC = RecordCache(100, "dns/ResolverTestCache.cache") #never written to self.res = Resolver(5, True, -1)
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 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