def constructQuery(header, domain_name, type):
"""
Constructs a binary-packed query using header, domain name and query type
"""
header_bin = header.pack()
question_entry = QE(type=type, dn=domain_name)
qe_bin = question_entry.pack()
new_query = header_bin + qe_bin
# print(new_query)
return new_query
def parse_network_data(this):
net_data = this.raw_packet
offset = 0
header = Header.fromData(net_data, offset)
offset += len(header)
query = QE.fromData(net_data, offset)
offset += len(query)
a_rr_list = []
ns_rr_list = []
ar_rr_list = []
for i in range(header._ancount):
if offset < len(net_data):
(a_rr, a_rr_len) = RR.fromData(net_data, offset)
offset += a_rr_len
a_rr_list.append(a_rr)
for i in range(header._nscount):
if offset < len(net_data):
(ns_rr, ns_rr_len) = RR.fromData(net_data, offset)
offset += ns_rr_len
ns_rr_list.append(ns_rr)
for i in range(header._arcount):
if offset < len(net_data):
(ar_rr, ar_rr_len) = RR.fromData(net_data, offset)
offset += ar_rr_len
if not ar_rr._type == -1:
ar_rr_list.append(ar_rr)
this.header = header
this.query = query
this.a_rr_list = a_rr_list
this.ns_rr_list = ns_rr_list
this.ar_rr_list = ar_rr_list
def printDeconstructOutgoing(data):
"""
Utility function for printing binary-packed query
"""
header = Header.fromData(data)
question_entry = QE.fromData(data, offset=len(header))
resource_records = []
offset = len(header) + len(question_entry)
while True:
try:
resource_record = RR.fromData(data, offset=offset)
offset += resource_record[1]
resource_records.append(resource_record)
except struct.error as error:
break
print(header, "\n")
print(question_entry, "\n")
for resource_record in resource_records:
if (resource_record[0]._type == 1):
print("authoritative record\n", resource_record[0])
elif (resource_record[0]._type == 2):
print("name server record\n", resource_record[0])
elif (resource_record[0]._type == RR.TYPE_CNAME):
print("canonical_name record\n", resource_record[0])
elif (resource_record[0]._type == RR.TYPE_AAAA):
print("name server record\n", resource_record[0])
def getEmptyRecord(data):
"""
Returns an empty record with type = RR.TYPE_UNKNOWN
"""
header = Header.fromData(data)
question_entry = QE.fromData(data, offset=len(header))
rr = RR.fromData(data, offset=len(header) + len(question_entry))
return data[-(rr[1]):]
def deconstructData(data):
"""
Deconstructs/Unpacks given binary data to Header, QE objects and a list of RR objects
"""
header = Header.fromData(data)
question_entry = QE.fromData(data, offset=len(header))
resource_records = []
offset = len(header) + len(question_entry)
while True:
try:
resource_record = RR.fromData(data, offset=offset)
offset += resource_record[1]
resource_records.append(resource_record[0])
except struct.error as error:
break
return (header, question_entry, resource_records)
def get_records(reply, n_ans, n_auth):
'''
#Function for gettting RR
We parse the data by getting the question section and then one-by-one getting an RR until we parsed all the data
and put them into lists and finally, one dictionary
:param reply: binary data received from a server as an answer for our request
:param n_ans: number of answer section RR records in the packet ('reply' is the binary representation of the packet)
:param n_auth: number of authentication section RR records in the packet
:return: return a dictionary where keys are labels of the RR types and values are lists containing all these resource
records categorized by these keys
'''
# Get question section and set initial offset for the remaining RR
reply_question = QE.fromData(reply, 12)
lengthData = len(reply)
offset_tmp = 12 + reply_question.__len__()
records_resources = []
# Looping through the data and constructing RR objects and append them to the list
while offset_tmp < lengthData:
record = RR.fromData(reply, offset_tmp)
records_resources.append(record[0])
offset_tmp += record[1]
rr_length = len(records_resources)
# Split up the list into multiple lists for all types of sections according to the length of each section
answers = records_resources[0:n_ans]
authorities = records_resources[n_ans:n_auth + n_ans]
additional = records_resources[n_auth + n_ans:rr_length]
additional_A = []
# Putting all A type additional records into a different list
if len(additional) != 0:
for record in additional:
if record._type == 1:
additional_A.append(record)
#Return dictionary with lists of sections
return {'answers': answers, 'authorities': authorities, 'additional': additional, 'additional_A': additional_A}
def printDeconstructIncoming(data):
"""
Another utility function for printing incoming data with no resource records
"""
header = Header.fromData(data)
question_entry = QE.fromData(data, offset=len(header))
resource_record = RR.fromData(data,
offset=(len(header) + len(question_entry)))
# resource_record2 = RR.fromData(data,offset=(len(header) + len(question_entry) + resource_record[1]))
print("Header Is ##################################")
print(header)
print("Header len", len(header))
print("Question entry is ############################")
print(question_entry)
print("Question len", len(question_entry))
print("Resource record is #########################")
print(resource_record[0])
print("###################")
def resolve_query(header_id, initial_domain_name, domain_name, current_ip, initial_ip, is_cname):
print("iteration")
'''
This is the main "powerhouse" function that serves a client request. Upon receiveing a domain name, it first checks
if it is contained in tha cache. If the cache contains information about the requested domain name, the function
returns it. The function will recursively search for the domain name asked for as specified in the lecture notes.
Cache also helps reducing queries by providing sub-domains for a domain name.
:param header_id: ID of the initial client query
:param initial_domain_name: the domain name the client was requesting
:param domain_name: the domain name this function is currently trying to resolve
:param current_ip: the current IP address we want to send a follow-up query to
:param initial_ip: the first IP address that our LNS sends a query to (always the Root Server in our case)
:param is_cname:
:return: a dictionary of lists containing RRs categorized by the section they belong to in the packet
'''
global acache
global cnamecache
global nscache
global global_cname
rr_return = {'answers': [], 'authorities': [], 'additional': [], 'additional_A': []}
# Only for the very first iteration (where domain_name == initial_domain_name) check if the requested domain name
# is inside the cache
if acache.contains(domain_name) and domain_name == initial_domain_name and not global_cname:
print("containsx")
# Get the IP and ttl from the cache and construct an RR_A object for answer section
ip = acache.getIpAddresses(domain_name)
ttl = acache.getExpiration(domain_name, ip[0])
rr_answer = RR_A(domain_name, ttl, ip[0]) #ip[0].toNetwork() if ip[0] is not in byte form
# Append the RR_A into the dictionary's answer section
rr_return['answers'].append(rr_answer)
# Constructing the authority section by looping through all possible sub-domains of domain_name and get the
# highest-qualified one that exists in the nscache
lowest_domain = get_subdomain_order(domain_name)
for i in range(len(lowest_domain)):
this_domain = DomainName(lowest_domain[i])
if nscache.contains(this_domain):
# Get the list of name servers associated with this domain name
something = nscache.get(this_domain)
for j in range(len(something)):
# For each name server associated with this domain name, retrieve the ttl and construct an
# RR_NS object and add it to the authority section of the dictionary
ttl = something[j][1]
nsdn = nscache.get_nsdn(this_domain)
rr_authorities = RR_NS(this_domain, ttl, nsdn[j])
rr_return['authorities'].append(rr_authorities)
# Check the IP address of all the name servers in the authority section, create an RR_A object and
# add it to the additional section of the dictionary
if acache.contains(nsdn[j]):
this_ip = acache.getIpAddresses(nsdn[j])
this_ttl = acache.getExpiration(nsdn[j], this_ip[0])
rr_additional = RR_A(nsdn[j], this_ttl, this_ip[0])
rr_return['additional'].append((rr_additional))
# If we found an existing sub-domain, look no further
break
return rr_return
# During the first iteration check what is the highest-qualified sub-domain that exists in the cache. If we find such
# sub-domain, jump straight to that sub-domain's IP address instead of doing more queries and causing traffic
if current_ip == initial_ip and not is_cname and not global_cname:
lowest_domain = get_subdomain_order(domain_name)
for i in range(len(lowest_domain)):
this_domain = DomainName(lowest_domain[i])
if nscache.contains(this_domain):
# Once we find that sub-domain, retrieve its IP address from the cache and recursively call
# serve_request() using the new IP address as target
nsdn = nscache.get_nsdn(this_domain)
next_ip = acache.getIpAddresses(nsdn[0])
return resolve_query(header_id, initial_domain_name, domain_name, next_ip, initial_ip, is_cname)
# Construct the packet
send_packet_header = Header(header_id, 0, 0, 1)
send_packet_question = QE(1, domain_name)
send_packet = send_packet_header.pack() + send_packet_question.pack()
# Send the packet to the target IP address and wait for an answer
cs.sendto(send_packet, (current_ip, 53))
reply, a = cs.recvfrom(512)
# Parse the reply and construct the RRs
header_record = parse_header(reply)
rr = get_records(reply, header_record['ancount'], header_record['nscount'])
# Cache all the RRs; this stage is only reached when these RRs are not duplicate, otherwise we would have reached
# them before, without needing to cause traffic
if header_record['ancount'] != 0: #len(rr['answers']) != 0:
for i in rr['answers']:
if i._type == 1:
acache.put(domain_name, i._addr, i._ttl)
elif i._type == 5:
cnamecache.put(domain_name, i._cname, i._ttl)
if header_record['nscount'] != 0:
for i in rr['authorities']:
if i._type == 2:
nscache.put(i._dn, i._nsdn, i._ttl, True)
if len(rr['additional']) != 0:
for i in rr['additional']:
if i._type == 1:
acache.put(i._dn, i._addr, i._ttl)
'''print("acache is:")
print(acache.__str__())
print("nscache is:")
print(nscache.__str__())
print("cnamecache is:")
print(cnamecache.__str__())'''
# Main recursive part
try:
# If there is no answer section and there is an additional section, make the same query targetting the first
# RR_A in additional section
if len(rr['additional']) != 0:
next_ip = bin_to_str(rr['additional_A'].pop(0)._addr)
return resolve_query(header_id, initial_domain_name, domain_name, next_ip, initial_ip, is_cname)
# If we have an answer section
elif header_record['ancount'] != 0:
# IF we found the domain name the client originally requested, return thr records
if initial_domain_name == domain_name:
return rr
# If we found a domain name from an authority section, we target this new domain's IP address with our query
else:
next_ip = bin_to_str(rr['answers'][0]._addr)
return resolve_query(header_id, initial_domain_name, initial_domain_name, next_ip, initial_ip, is_cname)
# If there is no answer and no RR_A additional section, we need to search for a domain name of the first RR_NS
# from the authority section recursively
else:
next_domain_name = rr['authorities'][0]._nsdn
return resolve_query(header_id, initial_domain_name, next_domain_name, ROOTNS_IN_ADDR, initial_ip, is_cname)
# If the server we send a question to does not respond, go ask the next server in the additional section
except timeout:
next_ip = bin_to_str(rr['additional_A'].pop(0)._addr)
return resolve_query(header_id, initial_domain_name, initial_domain_name, next_ip, initial_ip, is_cname)
cs = socket(AF_INET, SOCK_DGRAM)
# This is a simple, single-threaded server that takes successive
# connections with each iteration of the following loop:
while 1:
(data, client_address,) = ss.recvfrom(512) # DNS limits UDP msgs to 512 bytes
if not data:
logger.error("client provided no data")
continue
# Parse the header and answer section of the client query retrieving the domain name
lengthData = len(data)
query_header = Header.fromData(data)
header_id = query_header._id
question = QE.fromData(data, 12)
initial_qe_dn = question._dn
global_cname = False
# Use a function to ask for the requested domain name
packet = resolve_query(header_id, initial_qe_dn, initial_qe_dn, ROOTNS_IN_ADDR, ROOTNS_IN_ADDR, True)
new_packet = packet
# If the answer section contains CNAME then take that domain name and dig until there is no CNAME in the answer
while packet['answers'][0]._type == 5:
# Look for the new domain name and call the resolve_query function on it
global_cname = True
dn = packet['answers'][0]._cname
packet = resolve_query(header_id, dn, dn, ROOTNS_IN_ADDR, ROOTNS_IN_ADDR, True)
def recursiveLookup(data, address):
"""
Main recursive function - does everything
"""
answers = []
addresses = []
nameservers = []
cnames = []
originalHeader, originalQuery, originalRecords = deconstructData(data)
print("ORIGINAL are", originalRecords)
# If query took more than 50 seconds, returns server fail
if int(time()) - newQueryTime > 50:
"""
50 seconds on a safer side for timeout, returning SERV_FAIL RCODE in Header
"""
print("TOOK A LOT OF TIME")
originalHeader._rcode = Header.RCODE_SRVFAIL
originalHeader._ra = 1
originalHeader._aa = 0
originalHeader._qr = 1
return originalHeader.pack() + originalQuery.pack() + packRecords(
originalRecords)
#If answer already in cache, extract from cache
if acache.contains(originalQuery._dn):
finalRecords = b''
answers = getAddressFromCache(acache, originalQuery._dn)
#If length of answers is not zero, get from cache, else resolve manually
if len(answers) > 0:
nameservers, additionals = getNameserversFromCache(
nscache, acache, originalQuery._dn)
"""
Adjust header answer count for sending client back answer
"""
originalHeader._ancount = len(answers)
if len(nameservers) > 0:
answers.extend(nameservers)
if len(answers) > 0:
answers.extend(additionals)
for record in answers:
"""
Packing records into binary
"""
try:
# print(record)
finalRecords += record.pack()
except (struct.error, Exception) as e:
pp.pprint(e)
continue
"""
Adjust header attirbutes accordingly for sending client back answer
"""
originalHeader._nscount = len(nameservers)
originalHeader._arcount = len(additionals)
originalHeader._qr = 1
originalHeader._aa = 0
originalHeader._ra = 1
return originalHeader.pack() + originalQuery.pack() + finalRecords
# Manual resolving code
cs.sendto(data, (address, 53))
try:
# Send to new address and get data back
(serverData, serverAddress) = cs.recvfrom(512)
except (timeout, error):
#If timeout (greater than default timeout of 5 seconds of dig) , returns None
return None
header, question_entry, resource_records = deconstructData(serverData)
if header._rcode == Header.RCODE_NAMEERR or header._rcode == Header.RCODE_SRVFAIL:
originalHeader._rcode = Header.RCODE_SRVFAIL
originalHeader._ra = 1
originalHeader._aa = 0
originalHeader._qr = 1
print(originalRecords)
return originalHeader.pack() + originalQuery.pack(
) + EMPTY_RESOURCE_RECORD
if header._qdcount > 1:
print("CAN'T RESOLVE MULTIPLE QUERIES, EXITING...")
"""
Can't resolve multiple queries as mentioned in negative requirements
"""
return data
if (header._ancount > 0):
"""
Answer(s) exists already, no need to go further
"""
for i in range(header._ancount):
answers.append(resource_records[i])
for i in range(header._ancount, len(resource_records)):
if resource_records[i]._type == RR.TYPE_NS:
nameservers.append(resource_records[i])
putInCache(resource_records[i])
elif resource_records[i]._type == RR.TYPE_A:
addresses.append(resource_records[i])
putInCache(resource_records[i])
answer_record = resource_records[0]
if answer_record._type == RR.TYPE_A:
"""
If address, return binary packed server data
"""
return serverData
elif answer_record._type == 5:
"""
If type is CNAME, resolve the cname again from ROOT_DNS
"""
if cnamecache.contains(answer_record._dn
) and cnamecache.getCanonicalNameExpiration(
answer_record._dn) >= int(time()) - now:
# pass
cname = cnamecache.getCanonicalName(answer_record._dn)
furtherCnames = findMoreCnames(cname)
cname_addresses = []
if len(furtherCnames) == 0:
"""
Only single CNAME, so just find addresses of the CNAME
"""
cname_addresses.extend(getAddressFromCache(acache, cname))
if len(cname_addresses) > 0:
cname_addresses.insert(0, answer_record)
cname_nameservers, cname_additionals = getNameserversFromCache(
nscache, acache, cname)
cname_cache_bin = getRecords(cname_addresses,
cname_additionals,
cname_nameservers, data)
"""
Set appropriate header attrubutes w.r.t number of records
of each type (ancount,nscount and arcount)
"""
originalHeader._ancount = len(cname_addresses)
originalHeader._nscount = len(cname_nameservers)
originalHeader._arcount = len(cname_additionals)
originalHeader._qr = 1
originalHeader._aa = 0
originalHeader._ra = 1
originalHeader._rd = 0
return originalHeader.pack() + originalQuery.pack(
) + cname_cache_bin
else:
"""
If we could not find any addresses for cnames, resolve manually
"""
pass
else:
"""
CNAME itself has cnames(s), so get all CNAMES and use those
"""
try:
cflag = 0
cname_addresses.extend(furtherCnames)
"""
Get answers, nameservers and additionals
"""
cname_addresses.extend(
getAddressFromCache(acache, cname))
cname_nameservers, cname_additionals = getNameserversFromCache(
nscache, acache, cname)
for furtherCname in furtherCnames:
# print("LOOK FOR THE CNAME",cname,"FOR ADDRESSES")
if (len(
getAddressFromCache(
acache, furtherCname._cname)) > 0):
"""
Extra condition to make sure addresses of cnames haven't expired yet
If length of list of addresses of cname is zero, then resolve cnames again
"""
cflag = 1
# else:
# qec = furtherCnames[-1]._dn
# query = constructQuery(originalHeader,qec,QE.TYPE_A) + EMPTY_RESOURCE_RECORD
# cnameCacheData = recursiveLookup(query,ROOTNS_IN_ADDR)
# ch,cq,crr = deconstructData(cnameCacheData)
# ch._ancount += len(furtherCnames)
# crr_bin = b''
# for furtherCname in furtherCnames:
# crr_bin += furtherCname.pack()
# for cr in crr:
# crr_bin += cr.pack()
# return ch.pack() + cq.pack() + crr_bin
"""
Add all additional and glue records into pre-exisiting records to report
all possible high-level authorities for each CNAME
"""
cname_addresses.extend(
getAddressFromCache(acache,
furtherCname._cname))
cname_nameservers_temp, cname_additionals_temp = getNameserversFromCache(
nscache, acache, furtherCname._cname)
cname_additionals.extend(cname_additionals_temp)
cname_nameservers.extend(cname_nameservers_temp)
cname_addresses.insert(0, answer_record)
# print("FINAL CNAME ADDRS ARE",cname_addresses)
cname_cache_bin = getRecords(cname_addresses,
cname_additionals,
cname_nameservers, data)
"""
Adjust header attributes accordingly for returning answer
"""
originalHeader._ancount = len(cname_addresses)
originalHeader._nscount = len(cname_nameservers)
originalHeader._arcount = len(cname_additionals)
originalHeader._qr = 1
originalHeader._aa = 0
originalHeader._ra = 1
originalHeader._rd = 0
if cflag == 1:
return originalHeader.pack() + originalQuery.pack(
) + cname_cache_bin
else:
"""
If the addresses expired, need to find address of CNAME manually
"""
# print("NEED TO SEARCH SOME CNAME")
pass
except (struct.error, error, Exception) as e:
pass
else:
"""
CNAME not in cache, resolve CNAME manually
"""
putInCache(answer_record)
# print("Canonical record detected:",answer_record)
address_to_search = str(answer_record._cname)
# print(address_to_search)
cnameData = constructQuery(
header=Header.fromData(data),
domain_name=DomainName(address_to_search),
type=QE.TYPE_A) + EMPTY_RESOURCE_RECORD
"""
Recursive call for CNAME
"""
cnameServerData = recursiveLookup(cnameData, ROOTNS_IN_ADDR)
if cnameServerData is not None:
"""
Data got is not empty, form the answer by packing the data
and return the answer
"""
anscount = arcount = nscount = 0
cnameHeader, cnameQuestionEntry, cnameResourceRecords = deconstructData(
cnameServerData)
cnameResourceRecordsBin = b''
try:
cnameResourceRecordsBin += answer_record.pack()
except struct.error:
pass
anscount += 1
cnt = 0
for cnameRecord in cnameResourceRecords:
"""
Pack cnames in binary
"""
try:
if cnameRecord._type == RR.TYPE_CNAME:
cnameResourceRecordsBin = cnameResourceRecordsBin + cnameRecord.pack(
)
anscount += 1
putInCache(cnameRecord)
elif cnameRecord._type == RR.TYPE_A:
putInCache(cnameRecord)
cnameResourceRecordsBin = cnameResourceRecordsBin + cnameRecord.pack(
)
anscount += 1
else:
break
cnt += 1
except struct.error:
continue
"""
Pack authorities and glue records in binary
"""
rem = cnameResourceRecords[cnt:]
# print("REMAINING RECORDS PLEASE",rem)
for cnameRecord in rem:
try:
if cnameRecord._type == RR.TYPE_NS:
cnameResourceRecordsBin = cnameResourceRecordsBin + cnameRecord.pack(
)
nscount += 1
putInCache(cnameRecord)
elif cnameRecord._type == RR.TYPE_A:
cnameResourceRecordsBin = cnameResourceRecordsBin + cnameRecord.pack(
)
arcount += 1
putInCache(cnameRecord)
except struct.error:
continue
oldQuestionDomain = question_entry._dn
oldQuestionString = oldQuestionDomain.__str__()
cnameQuestionEntry = QE(type=QE.TYPE_A, dn=oldQuestionDomain)
cnameHeader._aa = 0
cnameHeader._ra = 1
cnameHeader._qr = 1
cnameHeader._ancount = anscount
cnameHeader._nscount = nscount
cnameHeader._arcount = arcount
cnameHeader._rd = 0
newCnameServerData = cnameHeader.pack(
) + cnameQuestionEntry.pack() + cnameResourceRecordsBin
# print("New data returned should be:")
# printDeconstructOutgoing(newCnameServerData)
return newCnameServerData
else:
print("ERROR - NO CANNONICAL RECORD FOUND, RETURNING...")
return None
else:
"""
No answers found, start searching glue records
"""
flag = 0
ns = []
add = []
"""
Utility for loops for grouping records into ns(nameservers) list and add(addresses) lisr
"""
for resource_record in resource_records:
if resource_record._type == RR.TYPE_NS:
ns.append(resource_record)
putInCache(resource_record)
elif resource_record._type == RR.TYPE_A:
add.append(resource_record)
putInCache(resource_record)
for record in resource_records:
if record._type == RR.TYPE_A:
putInCache(record)
new_address = str(InetAddr.fromNetwork(record._addr))
"""---------------------------RECURSIVE CALL-------------------------------)"""
newServerData = recursiveLookup(data, new_address)
if (newServerData is not None):
"""
Get header (in h), question entry (in q) and records (in rr)
for sending back to client for resolved answer
"""
h, q, rr = deconstructData(newServerData)
for i in range(h._ancount):
answers.append(rr[i])
putInCache(rr[i])
for i in range(h._ancount, len(rr)):
if rr[i]._type == RR.TYPE_NS:
nameservers.append(rr[i])
putInCache(rr[i])
elif rr[i]._type == RR.TYPE_A:
addresses.append(rr[i])
putInCache(rr[i])
"""
Utility code for additional glue records and authorities
"""
addresses.append(record)
for nameserver in ns:
putInCache(nameserver)
if str(record._dn) == str(nameserver._nsdn):
if nameserver not in nameservers:
nameservers.append(nameserver)
break
print("Success! Sending response to Client")
"""
Set the header appropriately w.r.t its attributes for returning final answer
"""
flag = 1
h._ancount = len(answers)
h._nscount = len(nameservers)
h._arcount = len(addresses)
h._aa = 0
h._ra = 1
h._qr = 1
h._rd = 1
rr_bin = getRecords(answers, addresses, nameservers,
newServerData)
# pp.pprint(answers)
# printDeconstructOutgoing(h.pack() + question_entry.pack() + rr_bin)
return h.pack() + question_entry.pack() + rr_bin
# return newServerData
else:
print("DIDNT GET ANYTHING BACK, continue")
continue
if flag == 1:
break
if flag == 0:
"""
NO glue records as well, resolve authority(ies) and then resolve
original question entry
"""
for record in resource_records:
"""
Check all authorities and start resolving them
to resolve original query
"""
if (record._type == RR.TYPE_NS):
"""
record found is nameserver authority
"""
putInCache(record)
# nameservers.append(record)
new_address = str(record._nsdn)
# print("SEARCH FOR", new_address)
"""
Construct query
"""
nsData = constructQuery(
header=Header.fromData(data),
domain_name=DomainName(new_address),
type=QE.TYPE_A) + EMPTY_RESOURCE_RECORD
"""-----------------------NS RECURSIVE CALL----------------)"""
nsServerData = recursiveLookup(nsData, ROOTNS_IN_ADDR)
if nsServerData is not None:
# print("Got from root")
# printDeconstructOutgoing(nsServerData)
nsHeader, nsQuestionEntry, nsResourceRecords = deconstructData(
nsServerData)
if (len(nsResourceRecords) == 0):
"""
Didnt find any answers for the authority,
continue resolving another authority
"""
continue
if (nsResourceRecords[0]._type == RR.TYPE_SOA):
"""
Not supposed to have SOA, so return None
"""
# print("SOA detected")
return None
nsIpAddress = ROOTNS_IN_ADDR
if nsHeader._ancount == 0:
"""
Didnt find any answers for the authority,
continue resolving another authority
"""
continue
else:
"""
Extract ip address of answer record got in resolving authority
"""
nsIpAddress = str(
InetAddr.fromNetwork(
nsResourceRecords[0]._addr))
# print("Success! Sending response to Client")
# nsIpAddress = str(InetAddr.fromNetwork(nsResourceRecords[0]._addr))
# print("Data to resolve")
# printDeconstructOutgoing(data)
# print("Resolved NS IP, now resolve:",question_entry,"using",nsIpAddress)
"""----------------RECURSIVE CALL TO RESOLVE ORIGINAL QUESTION----------------"""
newServerData = recursiveLookup(data, nsIpAddress)
if (newServerData is not None):
"""
Get header, question entry and resource records
Put in cache as well
"""
h, q, rr = deconstructData(newServerData)
for i in range(h._ancount):
answers.append(rr[i])
putInCache(rr[i])
for i in range(h._ancount, len(rr)):
if rr[i]._type == RR.TYPE_NS:
nameservers.append(rr[i])
putInCache(rr[i])
elif rr[i]._type == RR.TYPE_A:
addresses.append(rr[i])
putInCache(rr[i])
# print("Success! Sending response to Client")
flag = 1
"""
Set the header appropriately w.r.t its attributes for returning final answer
"""
h._ancount = len(answers)
h._nscount = len(nameservers)
h._arcount = len(addresses)
h._aa = False
h._ra = True
h._qr = 1
h._rd = 1
rr_bin = getRecords(answers, addresses,
nameservers, newServerData)
# pp.pprint(answers)
# printDeconstructOutgoing(h.pack() + question_entry.pack() + rr_bin)
return h.pack() + question_entry.pack() + rr_bin
# return newServerData
# print("Success! Sending response to Client")
# printDeconstructOutgoing(newServerData)
# return newServerData
else:
"""
If we couldt do anything for this authority,
then try the next one
"""
continue
elif (record._type == RR.TYPE_SOA):
"""
Handling SOA by returning just the original data
"""
# print("SOA detected, returning...")
return serverData
else:
continue
print("Literally nothing can be done")
"""
Server tried everything but failed to resolve, return SERV_FAIL RCODE in Header
"""
"""
EMPTY RECORD just for returning in failures
"""
returnRecord = EMPTY_RESOURCE_RECORD
header._rcode = Header.RCODE_SRVFAIL
return header.pack() + question_entry.pack() + returnRecord
def recursiveLookup(dn: DomainName) -> str:
if type(dn) == RR_SOA:
return dn
print("Lookup", dn)
cacheStatus = isInCache(dn)
if cacheStatus == 1:
print("Found IP for", dn)
return getIpsFromCache(dn)[0]
elif cacheStatus == 2:
print("Found NS for", dn)
toLookup = getGlueNamesFromCache(dn)[count]
elif cacheStatus == 3:
print("Found CN for", dn)
toLookup = cnamecache.getCanonicalName(dn)
stack.append(dn)
elif cacheStatus == 0:
# No data is cached
print("No cached data for", dn)
payload = Header(
50000,
opcode=Header.OPCODE_QUERY,
rcode=Header.RCODE_NOERR,
qr=0, # 1 -response, 0=query
qdcount=1, # Questions #
).pack()
payload += QE(dn=dn, type=QE.TYPE_A).pack()
parentIp = recursiveLookup(dn.parent())
if type(parentIp) == RR_SOA:
return parentIp
cs.sendto(payload, (parentIp, 53))
data = cs.recvfrom(512)[0]
# Unpack client response data
headerLen = len(Header.fromData(data))
questionLen = len(QE.fromData(data, offset=headerLen))
offset = headerLen + questionLen
while offset < len(data):
# Iterate by framesize
curFrame = RR.fromData(data, offset=offset)
rr = curFrame[0]
if type(rr) == RR_NS:
print("Caching NS", rr.__str__())
nscache.put(rr._dn, rr._nsdn, (time() + rr._ttl), True)
elif type(rr) == RR_A:
print("Caching A", rr.__str__())
acache.put(
rr._dn,
InetAddr.fromNetwork(rr._addr),
(time() + rr._ttl),
authoritative=False,
)
elif type(rr) == RR_AAAA:
pass
elif type(rr) == RR_CNAME:
print("Caching CNAME", rr.__str__())
cnamecache.put(rr._dn, rr._cname, (time() + rr._ttl))
stack.append(rr._dn)
elif type(rr) == RR_SOA:
print("Exiting: Found SOA", rr.__str__())
return rr
else:
logger.log(DEBUG2, "Unknown RR: {}".format(rr))
offset += curFrame[1]
toLookup = dn
print("Looking again for", toLookup)
cacheStatus = isInCache(toLookup)
if cacheStatus in [2, 3]:
# No glues exist for this dn
reloadGlues = recursiveLookup(
getGlueNamesFromCache(toLookup)[0])
if type(reloadGlues) == RR_SOA:
return reloadGlues
resIps = getIpsFromCache(getGlueNamesFromCache(toLookup)[0])
elif cacheStatus == 3:
resIps = recursiveLookup(getGlueNamesFromCache(toLookup)[0])
else:
resIps = getIpsFromCache(toLookup)
return resIps[0]
# This is a simple, single-threaded server that takes successive
# connections with each iteration of the following loop:
while 1:
ss.settimeout(None)
(data,
client_address) = ss.recvfrom(512) # DNS limits UDP msgs to 512 bytes
if not data and not Header.fromData(data)._qdcount == 1:
logger.log(DEBUG2, "client provided no data")
continue
ss.settimeout(60)
queryHeader = Header.fromData(data)
queryQuestion = QE.fromData(data, offset=12)
queryDomain = queryQuestion._dn
print("Query received from client is:\n%s" % (hexdump(data)))
count = 2
stack = []
try:
def recursiveLookup(dn: DomainName) -> str:
if type(dn) == RR_SOA:
return dn
print("Lookup", dn)
cacheStatus = isInCache(dn)
if cacheStatus == 1:
print("Found IP for", dn)
return getIpsFromCache(dn)[0]
elif cacheStatus == 2:
def recurser(question, ipQuerried):
queryHeader = Header.fromData(question)
queryQE = QE.fromData(question, queryHeader.__len__())
if acache.contains(queryQE._dn):
ips = acache.getIpAddresses(queryQE._dn)
foundRRA = 0
for ip in ips:
ttl = acache.getExpiration(queryQE._dn, ip) - int(time())
if ttl < 0:
# too late for this record
acache.cache.pop(queryQE._dn)
else:
answers.append(RR_A(queryQE._dn, ttl, inet_aton(ip)))
foundRRA = 1
if foundRRA is 1:
newHeader = Header(queryHeader._id, 0, 0, 1, ancount=len(answers))
newQE = QE(dn=queryQE._dn)
return newHeader.pack() + newQE.pack()
elif cnamecache.contains(queryQE._dn):
cn = cnamecache.getCanonicalName(queryQE._dn)
ttl = cnamecache.getCanonicalNameExpiration(queryQE._dn) - int(time())
if ttl < 0:
cnamecache.cache.pop(queryQE._dn)
else:
newHeader = Header(queryHeader._id, 0, 0, 1)
newQE = QE(dn=cn)
reply = recurser(newHeader.pack() + newQE.pack(), ROOTNS_IN_ADDR)
if reply != None:
answers.append(RR_CNAME(queryQE._dn, ttl, cn))
return reply
try:
cs.sendto(question, (ipQuerried, 53))
(
nsreply,
server_address,
) = cs.recvfrom(2048) # some queries require more space
except timeout:
return None
if len(nsreply) < 43:
return None # handle case where there is an empty response
# Store these for later use when we want to solve CNAMEs or NSs
queryHeader = Header.fromData(nsreply)
queryQE = QE.fromData(nsreply, queryHeader.__len__())
originalQ = str(queryQE).split("IN")[0].strip()
offset = queryHeader.__len__() + queryQE.__len__()
# We'll need these for parsing, trust me
minRRLineLen = len(nsreply) - offset - 1
rrCounter = 0
nsAuthorities = []
rra = []
cnames = []
queryRRTuples = []
# Parsing all returned RRs
while minRRLineLen < len(nsreply) - offset:
# Get next glue line
auxRRline = RR.fromData(nsreply, offset)
# Append to RR list, update offset
queryRRTuples.append(auxRRline)
offset += queryRRTuples[rrCounter][1]
queryRR = queryRRTuples[rrCounter][0]
if queryRR.__class__ == RR_NS:
nsAuthorities.append(queryRR)
elif queryRR.__class__ == RR_A:
rra.append(queryRR)
elif queryRR.__class__ == RR_CNAME:
cnames.append(queryRR)
# Update minimum line length for safety stop
if minRRLineLen > auxRRline[1]: minRRLineLen = auxRRline[1]
rrCounter += 1
# Start the handling of RRs
# Case where we only got NS back
if len(rra) == 0 and len(cnames) == 0:
for auth in nsAuthorities:
reply = recurser(question, str(auth._nsdn))
return reply
# Cache NS for later
if len(nsAuthorities) > 0:
for ns in nsAuthorities:
nscache.put(ns._dn,
ns._nsdn,
ns._ttl + int(time()),
authoritative=True)
# Cache CNAMEs for later and querry them
if len(cnames) > 0:
for queryRR in cnames:
if cnamecache.contains(queryRR._dn) == False:
cnamecache.put(queryRR._dn, queryRR._cname,
queryRR._ttl + int(time()))
answers.append(queryRR)
newHeader = Header(randint(1, 65000),
Header.OPCODE_QUERY,
Header.RCODE_NOERR,
qdcount=1)
newQE = QE(dn=queryRR._cname)
newQuery = newHeader.pack() + newQE.pack()
reply = recurser(newQuery, ROOTNS_IN_ADDR)
return reply
# Cache all RR_As for later, look if we got the one we are looking for
if len(rra) > 0:
for queryRR in rra:
if acache.contains(queryRR._dn) == False:
acache.put(queryRR._dn,
inet_ntoa(queryRR._addr),
queryRR._ttl + int(time()),
authoritative=True)
parts = queryRR.__str__().split("A")
ip = parts[len(parts) - 1].strip()
# Found required answer
if queryRR._dn == originalQ:
# Add all answers
counter = 0
while counter < len(rra):
if rra[counter]._dn == originalQ:
answers.append(rra[counter])
rra.pop(counter)
counter += 1
return nsreply
else:
reply = recurser(question, ip)
return reply
# Making sure those globals are ready to be used
answers = []
auths = []
additionals = []
if not data:
log.error("client provided no data")
continue
else:
# Saving all this data for response reconstrucion later
question = data
ip = ROOTNS_IN_ADDR
initialHeader = Header.fromData(data)
initialQE = QE.fromData(data, initialHeader.__len__())
initialId = initialHeader._id
# The call to solve the main query
nsreply = recurser(question, ip)
if nsreply == None:
# Respond with name error
newHeader = Header(initialId, 0, Header.RCODE_NAMEERR, 1)
response = newHeader.pack() + initialQE.pack()
else:
# Save these because we were using globals (never a good practice - too late now, sue me)
finalAns = []
finalAns.extend(answers)
responseRRA = ""