def on_udp_query(self, req_data, addr):
start_time = time.time()
try:
request = DNSRecord.parse(req_data)
if len(request.questions) != 1:
xlog.warn("query num:%d %s", len(request.questions), request)
return
domain = str(request.questions[0].qname)
type = request.questions[0].qtype
if type not in [1, 28]:
xlog.warn("query:%s type:%d", domain, type)
# xlog.debug("DNS query:%s type:%d from %s", domain, type, addr)
ips = self.query(domain, type)
reply = DNSRecord(DNSHeader(id=request.header.id, qr=1, aa=1, ra=1, auth=1), q=request.q)
for ip_cn in ips:
ipcn_p = ip_cn.split("|")
ip = ipcn_p[0]
if "." in ip and type == 1:
reply.add_answer(RR(domain, ttl=60, rdata=A(ip)))
elif ":" in ip and type == 28:
reply.add_answer(RR(domain, rtype=type, ttl=60, rdata=AAAA(ip)))
res_data = reply.pack()
self.serverSock.sendto(res_data, addr)
xlog.debug("query:%s type:%d from:%s, return ip num:%d cost:%d", domain, type, addr,
len(reply.rr), (time.time()-start_time)*1000)
except Exception as e:
xlog.exception("on_query except:%r", e)
def query(self, qname, qtype="A", qclass="IN"):
qtype = QTYPE.reverse[qtype]
qclass = CLASS.reverse[qclass]
q = DNSRecord(q=DNSQuestion(qname, qtype, qclass))
self.fire(write((self.server, self.port), q.pack()))
def dns_handler(s, peer, data):
request = DNSRecord.parse(data)
id = request.header.id
qname = request.q.qname
qtype = request.q.qtype
print "------ Request (%s): %r (%s)" % (str(peer),
qname.label, QTYPE[qtype])
print "\n".join([ " %s" % l for l in str(request).split("\n")])
reply = DNSRecord(DNSHeader(id=id, qr=1, aa=1, ra=1), q=request.q)
if qtype == QTYPE.A:
reply.add_answer(RR(qname, qtype, rdata=A(IP)))
if qtype == QTYPE.AAAA:
reply.add_answer(RR(qname, qtype, rdata=AAAA(IPV6)))
elif qtype == QTYPE['*']:
reply.add_answer(RR(qname, QTYPE.A, rdata=A(IP)))
reply.add_answer(RR(qname, QTYPE.MX, rdata=MX(IP)))
reply.add_answer(RR(qname, QTYPE.TXT, rdata=TXT(MSG)))
else:
reply.add_answer(RR(qname, QTYPE.CNAME, rdata=CNAME(MSG)))
print "------ Reply"
print "\n".join([ " %s" % l for l in str(reply).split("\n")])
s.sendto(reply.pack(), peer)
def DNSGuard(ip, port, blacklist):
octetsize = 512
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((ip, port))
data = None
addr = None
R = resolver.Resolver()
logging.debug("DNSGuard SERVER ACTIVE ON {}:{}".format(ip, port))
while True:
data, addr = sock.recvfrom(octetsize)
packet = DNSRecord.parse(data)
question = packet.get_q()
fqdn = FQDN(question)
logging.debug("Query: {}".format(str(packet)))
if allowed(fqdn, blacklist):
try:
zones = R.resolveZone([fqdn])
logging.debug("Allowed: {}".format(zones))
reply = packet.reply()
for zone in zones:
reply.add_answer(*RR.fromZone(zone))
sock.sendto(DNSRecord.pack(reply), addr)
except Exception as e:
logging.error("Error: {}".format(e))
pass
pass
def query(self, domain, dns_type=1):
try:
t0 = time.time()
client = self.get_connection()
url = self.server
d = DNSRecord(DNSHeader())
d.add_question(DNSQuestion(domain, dns_type))
data = d.pack()
r = client.request("POST", url, headers={"accept": "application/dns-message",
"content-type": "application/dns-message"}, body=data)
t2 = time.time()
p = DNSRecord.parse(r.text)
ips = []
for r in p.rr:
ip = utils.to_bytes(str(r.rdata))
ips.append(ip)
self.connections.append([client, time.time()])
xlog.debug("Dns %s %s return %s t:%f", self.protocol, domain, ips, t2 - t0)
return ips
except Exception as e:
xlog.exception("DnsOverHttpsQuery query fail:%r", e)
return []
def dns_handler(s, peer, data):
request = DNSRecord.parse(data)
id = request.header.id
qname = request.q.qname
qtype = request.q.qtype
reply = DNSRecord(DNSHeader(id=id, qr=1, aa=1, ra=1), q=request.q)
if "secsquare.herokuapp.com" == qname:
# if the query is for SecSquare server
reply.add_answer(RR(qname,qtype, rdata=A(SECSQUARE_HOST_ADDRESS)))
else:
# if query is for any other host names
label = str(qname)
raw_data = urllib2.urlopen("https://secsquare.herokuapp.com/api.php?name="+label).read()
data = json.loads(raw_data)
results = data['results']
for entry in results:
# put all results from SecSquare server into reply
if 'MX' in entry['type']:
reply.add_answer(RR(qname,qtype, rdata=MX(entry['target'])))
elif 'AAAA' in entry['type']:
reply.add_answer(RR(qname,qtype, rdata=AAAA(entry['ipv6'])))
elif 'A' in entry['type']:
reply.add_answer(RR(qname,qtype, rdata=A(entry['ip'])))
print(reply) # print the DNS response for debugging purposes
s.sendto(reply.pack(), peer)
def dns_response_for_sending(self):
self.client_data_holder.parsed_dns_response.header.id = self.client_data_holder.parsed_dns_request.header.id
self.client_data_holder.raw_dns_response = DNSRecord.pack(
self.client_data_holder.parsed_dns_response)
logger.debug(
f"[Process: Packing Data For Sending], Request_Header_ID: [{self.client_data_holder.parsed_dns_request.header.id}], Response_Data: [{self.client_data_holder.raw_dns_response}]"
)
def query(self, qname, qtype="A", qclass="IN"):
qtype = QTYPE.reverse[qtype]
qclass = CLASS.reverse[qclass]
q = DNSRecord(q=DNSQuestion(qname, qtype, qclass))
self.fire(write((self.server, self.port), q.pack()))
def query(self, peer, request):
id = request.header.id
qname = request.q.qname
queryType = request.q.qtype
reply = DNSRecord( DNSHeader(id=id, qr=1, aa=1, ra=1), q=request.q )
def cnameRecursion(dHost):
global tmpRes # used for overwriting previous recursion value
tmpData = dbTest(dHost)
# First: get CNAME of desired host
cnameAddress = [i[1] for i in tmpData if i[0] == 'CNAME']
tmpRes = (dHost,tmpData)
if cnameAddress:
newAddr = checkMacro(cnameAddress[0],dHost,peer)
reply.add_answer(RR(dHost, QTYPE.CNAME, rdata=CNAME(newAddr)))
# Second: get desired QTYPE from desired host
printOut(peer,QTYPE.CNAME,str(dHost),newAddr)
cnameRecursion(newAddr)
return tmpRes
qname,rData = cnameRecursion(qname)
if queryType == QTYPE.TXT: # TXT
rData = [i[1] for i in rData if i[0] == 'TXT']
# Add TXT Record
printData = []
for tmprecord in rData:
record = checkMacro(tmprecord,qname,peer)
n = 255
if len(record) > 20:
printData += [ record[:15]+'...(%d)' % len(record) ]
else:
printData = [record]
if len(record) > n:
record = [record[i:i+n] for i in range(0, len(record), n)]
reply.add_answer(RR(qname, QTYPE.TXT, rdata=TXT(record if isinstance(record,list) else [record,])))
printOut(peer,queryType,str(qname),printData)
else:
rData = [i[1] for i in rData if i[0] == qTypeDict[queryType]]
resIP = ''
if len(rData):
resIP = rData
elif '*' in db:
#elif db.has_key('*'): #python2 only
resIP = [i[1] for i in dbTest('*') if i[0] == 'A']
for tmpip in resIP:
ip = checkMacro(tmpip,qname,peer)
# Add A Record
reply.add_answer(RR(qname, QTYPE.A, rdata=A(ip)))
if resIP:
printOut(peer,queryType,str(qname),', '.join(resIP))
else:
printOut(peer,queryType,str(qname),'NONE')
# Send To Client
self.fire(write(peer, reply.pack()))
def dns_handler(s, peer, data):
request = DNSRecord.parse(data)
id = request.header.id
qname = request.q.qname
qtype = request.q.qtype
print "------ Request (%s): %r (%s)" % (str(peer), qname.label,
QTYPE[qtype])
print request
reply = DNSRecord(DNSHeader(id=id, qr=1, aa=1, ra=1), q=request.q)
if qtype == QTYPE.A:
reply.add_answer(RR(qname, qtype, rdata=A(IP)))
if qtype == QTYPE.AAAA:
reply.add_answer(RR(qname, qtype, rdata=AAAA(IPV6)))
elif qtype == QTYPE['*']:
reply.add_answer(RR(qname, QTYPE.A, rdata=A(IP)))
reply.add_answer(RR(qname, QTYPE.MX, rdata=MX(IP)))
reply.add_answer(RR(qname, QTYPE.TXT, rdata=TXT(MSG)))
else:
reply.add_answer(RR(qname, QTYPE.CNAME, rdata=CNAME(MSG)))
print "------ Reply"
print reply
s.sendto(reply.pack(), peer)
def resolve_mdns(self, request, handler, rewrite=None):
sock = get_mdns_socket()
d = DNSRecord(DNSHeader(id=0, bitmap=0), q=request.q)
sock.sendto(d.pack(), (nameserver4, 5353))
# sock.sendto(d.pack(), (nameserver6, 5353))
qname = request.q.qname
if rewrite:
request.q.qname = rewrite
reply = request.reply()
while True:
buf, remote = sock.recvfrom(8192)
d = DNSRecord.parse(buf)
success = False
if (d.header.aa == 1) and (d.header.a > 0):
for response in d.rr:
if str(response.rname) == qname:
success = True
response.rclass = CLASS.IN
# These two lines can be deleted if we dont want the original response
reply.add_answer(response)
response = RR.fromZone(response.toZone())[0]
if rewrite:
response.rname = rewrite
reply.add_answer(response)
# print(reply)
if success:
break
return reply
def dns_response(self, data):
request = DNSRecord.parse(data)
logger.debug('%s', request)
reply = DNSRecord(DNSHeader(id=request.header.id, qr=1, aa=1, ra=1),
q=request.q)
qname = request.q.qname
qn = str(qname)
if qn.endswith('.'):
qn = qn[:-1]
qtype = request.q.qtype
qt = QTYPE[qtype]
qnhost, qndomain = qn.split('.', 1)
#
# OK, so we are not conformant to the standards at all, as we never
# return any SOA records and stuff...
#
if qndomain == settings.IPAUTH_DNSSERVER_DOMAIN:
if qt in ['*', 'A']:
for u in User.objects.filter(iptouser__isnull=False):
if qnhost == username_to_hostname(u.username):
for itu in u.iptouser_set.all():
reply.add_answer(
RR(
rname=qname,
rtype=QTYPE.A,
rclass=1,
ttl=self.server.command.options['ttl'],
rdata=A(itu.ip_addr),
))
elif qn.endswith('.in-addr.arpa'):
if qt in ['*', 'PTR']:
qn = qn[:-len('.in-addr.arpa')]
parts = qn.split('.')
if len(parts) == 4:
ip = '.'.join(reversed(parts))
try:
iptu = IpToUser.objects.get(ip_addr=ip)
fqdn = (username_to_hostname(iptu.user.username) +
'.' + settings.IPAUTH_DNSSERVER_DOMAIN + '.')
reply.add_answer(
RR(
rname=qname,
rtype=QTYPE.PTR,
rclass=1,
ttl=self.server.command.options['ttl'],
rdata=PTR(fqdn),
))
except IpToUser.DoesNotExist:
pass
logger.debug('%s', reply)
return reply.pack()
def take_from_cache(key, ident):
name = '.'.join(key.split('.')[:-1])
header = DNSHeader(id=ident, aa=0, qr=1, ra=1, rcode=0)
question = DNSQuestion(name, REV_TYPES_DICT[key.split('.')[-1]])
answer = DNSRecord(header=header, q=question)
for rec in cache[key]:
answer.add_answer(rec)
return answer.pack()
def manufactory_DNS(self):
response_packet = DNSRecord()
response_packet.header.id = self.query_id
response_packet.add_question(DNSQuestion(self.qname, self.qtype))
related_rr = filter(lambda rr: self.qname in rr, intercept_rr)
for answer in related_rr:
response_packet.add_answer(*RR.fromZone(answer))
self.response_packet = response_packet.pack().__str__()
def _reply(self, rec, addrs=None):
reply = DNSRecord(DNSHeader(id=rec.header.id, qr=1, aa=1, ra=1), q=rec.q)
if addrs:
if not isinstance(addrs, list):
addrs = [addrs]
for addr in addrs:
reply.add_answer(RR(rec.q.qname, QTYPE.A, rdata=A(addr)))
return reply.pack()
def send_request(self, id, domain, server):
try:
d = DNSRecord(DNSHeader(id))
d.add_question(DNSQuestion(domain, QTYPE.A))
req4_pack = d.pack()
d = DNSRecord(DNSHeader(id))
d.add_question(DNSQuestion(domain, QTYPE.AAAA))
req6_pack = d.pack()
self.sock.sendto(req4_pack, (server, 53))
# xlog.debug("send req:%s to:%s", domain, server)
self.sock.sendto(req6_pack, (server, 53))
# xlog.debug("send req:%s to:%s", domain, server)
except Exception as e:
xlog.warn("send_request except:%r", e)
def send_req_to_server(server_addr, name):
client_req = DNSRecord(DNSHeader(id=ID), q=DNSQuestion(name, getattr(QTYPE, "A")))
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect((server_addr, 53))
s.send(client_req.pack())
resp = s.recv(2048)
dns_resp = DNSRecord.parse(resp)
logging.warning("Got answer from server {}".format(dns_resp))
def _reply(self, rec, addr=None):
reply = DNSRecord(DNSHeader(id=rec.header.id, qr=1, aa=1, ra=1), q=rec.q)
if addr:
qtype = QTYPE.A if QTYPE.A == rec.q.qtype else QTYPE.AAAA
reply.add_answer(RR(rec.q.qname, qtype, rdata=A(addr)))
rep = reply.pack()
return rep
def send_request(self, id, domain, server):
try:
d = DNSRecord(DNSHeader(id))
d.add_question(DNSQuestion(domain, QTYPE.A))
req4_pack = d.pack()
d = DNSRecord(DNSHeader(id))
d.add_question(DNSQuestion(domain, QTYPE.AAAA))
req6_pack = d.pack()
self.sock.sendto(req4_pack, (server, 53))
# xlog.debug("send req:%s to:%s", domain, server)
self.sock.sendto(req6_pack, (server, 53))
# xlog.debug("send req:%s to:%s", domain, server)
except Exception as e:
xlog.warn("send_request except:%r", e)
def _reply(self, rec, addrs=None):
reply = DNSRecord(DNSHeader(id=rec.header.id, qr=1, aa=1, ra=1),
q=rec.q)
if addrs:
if not isinstance(addrs, list):
addrs = [addrs]
for addr in addrs:
reply.add_answer(RR(rec.q.qname, QTYPE.A, rdata=A(addr)))
return reply.pack()
def send_request(self, id, server_ip, domain, dns_type):
try:
d = DNSRecord(DNSHeader(id))
d.add_question(DNSQuestion(domain, dns_type))
req4_pack = d.pack()
self.sock.sendto(req4_pack, (server_ip, 53))
except Exception as e:
xlog.warn("send_request except:%r", e)
def send_dns_packet(sock, server_addr, name, ip, id):
"""
Construct and send dns packet
"""
ans = DNSRecord(DNSHeader(id=id, qr=1))
ans.add_question(DNSQuestion(name))
ans.add_answer(RR(name, ttl=3600, rdata=A(ip)))
# print(ans)
sock.sendto(ans.pack(), (server_addr, 7131))
def read(self, peer, data):
try:
self.fire(query(peer, DNSRecord.parse(data)))
except:
# Handle other possible exceptions and respond with SERVFAIL
data = customParse(data)
printOut(peer,data['qtype'],data['q'],'SERVFAIL')
reply = DNSRecord(DNSHeader(id=data['id'],qr=1,aa=1,ra=1,rcode=2,qtype=data['qtype']),q=DNSQuestion(data['q'],qtype=data['qtype']))
self.fire(write(peer, reply.pack()))
def validate_and_dns_name_setup(self, dns_request, client_address):
logger.debug(f"[Process : Validate & Dns Name Setup]") ## Debugging
validation_result = False
validation_info = "Improper/Forged Dns Request"
custom_parsed_dns_response = None
try:
parsed_dns_request = DNSRecord.parse(dns_request)
req_dns_name = str(parsed_dns_request.questions[0].qname)
req_dns_type = int(parsed_dns_request.questions[0].qtype)
if req_dns_name in self.dns_name.keys():
dns_name_to_set = self.dns_name[req_dns_name]
logger.debug(f"IP ADDR LIST: {dns_name_to_set.split(',')}")
custom_parsed_dns_response = DnsBuilder.create_dns_response(
parsed_dns_request=parsed_dns_request,
req_dns_name=req_dns_name,
req_dns_type=req_dns_type,
ip_address_list=dns_name_to_set.split(","))
validation_info = ""
else:
validation_result = True
validation_info = ""
self.domain_name_extractor(
requested_domain_name=req_dns_name,
requested_domain_name_type=req_dns_type
) #Extract Proper Info From the Dns Requested Domain
except (dnslib.buffer.BufferError,
dnslib.dns.DNSError) as dns_parsing_error:
logger.error(
f"[Process: Validation By using parse()] "
f"[Error: DnsRecord.parse() Exception, Data Received is INCORRECT, "
f"Exception: [{dns_parsing_error}]",
exc_info=True)
# Enable StackTrace in Logs
validation_info = validation_info + f", Exception: [{dns_parsing_error}]"
except Exception as all_exception:
logger.error(
f"[Process: Validation By using parse()] "
f"[Error: Unknown Exception] "
f"Exception: [{all_exception}]",
exc_info=True)
# Enable StackTrace in Logs
validation_info = validation_info + f", Exception: [{all_exception}]"
finally:
if validation_result:
logger.debug(
f"Process Complete Validation INFO: [{validation_info}, {custom_parsed_dns_response}]"
)
return validation_result
else:
if validation_info == "":
self.send_response_to_client(
client_address=client_address,
raw_dns_response=DNSRecord.pack(
custom_parsed_dns_response),
status_tag=validation_info)
return None
def _resolve_question(self, resolve_question: DNSRecord,
ns_address: str) -> DNSRecord:
self._question_socket.sendto(resolve_question.pack(), (ns_address, 53))
try:
ns_raw_answer, _ = self._question_socket.recvfrom(4096)
return DNSRecord.parse(ns_raw_answer)
except (socket_timeout, DNSError):
return DNSRecord()
def query(self, domain, dns_type=1):
t0 = time.time()
try:
sock = self.get_connection()
if not sock:
xlog.warn("query_over_tcp %s type:%s connect fail.", domain,
dns_type)
return []
d = DNSRecord(DNSHeader())
d.add_question(DNSQuestion(domain, dns_type))
data = d.pack()
data = struct.pack("!H", len(data)) + data
sock.sendall(data)
response = sock.recv(8192)
if not response:
return []
length = struct.unpack("!H", bytes(response[:2]))[0]
while len(response) - 2 < length:
response += sock.recv(8192)
t2 = time.time()
p = DNSRecord.parse(response[2:])
if len(p.rr) == 0:
xlog.warn("query_over_tcp for %s type:%d return none, cost:%f",
domain, dns_type, t2 - t0)
ips = []
for r in p.rr:
ip = utils.to_bytes(str(r.rdata))
if not utils.check_ip_valid(ip):
if ip == domain:
continue
ip_ips = self.query(ip, dns_type)
ips += ip_ips
else:
ips.append(ip)
xlog.debug("DNS %s %s return %s t:%f", self.protocol, domain, ips,
t2 - t0)
self.connections.append([sock, time.time()])
return ips
except socket.timeout:
xlog.warn("query_over_tcp %s type:%s timeout", domain, dns_type)
return []
except Exception as e:
xlog.exception("query_over_tcp %s type:%s except:%r", domain,
dns_type, e)
return []
def response_str_in_txt(request, data: str):
'''
将字符串包装在TXT记录里作为结果返回
return: bytes
'''
request = DNSRecord.parse(request)
qname = request.q.qname
qtype = request.q.qtype
reply = DNSRecord(DNSHeader(id=request.header.id, qr=1, aa=1, ra=1),
q=request.q)
reply.add_answer(RR(qname, qtype, rdata=TXT(data)))
return reply.pack()
def send_request(self, id, domain):
try:
d = DNSRecord(DNSHeader(id))
d.add_question(DNSQuestion(domain, QTYPE.A))
req4_pack = d.pack()
d = DNSRecord()
d.add_question(DNSQuestion(domain, QTYPE.AAAA))
req6_pack = d.pack()
if "." in domain:
server = self.dns_server.get()
else:
server = self.dns_server.get_local_server()
self.sock.sendto(req4_pack, (server, 53))
# xlog.debug("send req:%s to:%s", domain, server)
self.sock.sendto(req6_pack, (server, 53))
# xlog.debug("send req:%s to:%s", domain, server)
except Exception as e:
xlog.warn("request dns except:%r", e)
def send_request(self, id, domain):
try:
d = DNSRecord(DNSHeader(id))
d.add_question(DNSQuestion(domain, QTYPE.A))
req4_pack = d.pack()
d = DNSRecord()
d.add_question(DNSQuestion(domain, QTYPE.AAAA))
req6_pack = d.pack()
if "." in domain:
server = self.dns_server.get()
else:
server = self.dns_server.get_local_server()
self.sock.sendto(req4_pack, (server, 53))
# xlog.debug("send req:%s to:%s", domain, server)
self.sock.sendto(req6_pack, (server, 53))
# xlog.debug("send req:%s to:%s", domain, server)
except Exception as e:
xlog.warn("request dns except:%r", e)
def query(self, domain, dns_type=1):
t0 = time.time()
try:
client = self.get_connection()
url = self.server
d = DNSRecord(DNSHeader())
d.add_question(DNSQuestion(domain, dns_type))
data = d.pack()
r = client.request("POST",
url,
headers={
"accept": "application/dns-message",
"content-type": "application/dns-message"
},
body=data)
t2 = time.time()
ips = []
if not r:
xlog.warn("DNS s:%s query:%s fail t:%f", self.server, domain,
t2 - t0)
return ips
p = DNSRecord.parse(r.text)
self.connections.append([client, time.time()])
for r in p.rr:
ip = utils.to_bytes(str(r.rdata))
if not utils.check_ip_valid(ip):
if ip == domain:
continue
ip_ips = self.query(ip, dns_type)
ips += ip_ips
else:
ips.append(ip)
xlog.debug("DNS %s %s return %s t:%f", self.protocol, domain, ips,
t2 - t0)
return ips
except Exception as e:
t1 = time.time()
t = t1 - t0
xlog.exception("DnsOverHttpsQuery query %s cost:%f fail:%r",
domain, t, e)
return []
def cloudflare_dns_over_tls(dns_request: DNSRecord) -> DNSRecord:
logging.debug('handling DNS request: \n%s', dns_request)
with socket.create_connection((CLOUDFLARE_DNS, 853)) as sock:
with context.wrap_socket(sock,
server_hostname=CLOUDFLARE_DNS) as ssock:
data = dns_request.pack()
if len(data) > 65535:
raise ValueError(f'Packet too long: {len(data)}')
data = struct.pack('!H', len(data)) + data
ssock.sendall(data)
dns_response = get_dns_request_over_tcp(ssock)
logging.debug('got DNS response from cloudflare: \n%s',
dns_response)
return dns_response
def dns_response(self, data):
request = DNSRecord.parse(data)
logger.debug('%s', request)
reply = DNSRecord(DNSHeader(id=request.header.id, qr=1, aa=1, ra=1),
q=request.q)
qname = request.q.qname
qn = str(qname)
if qn.endswith('.'):
qn = qn[:-1]
qtype = request.q.qtype
qt = QTYPE[qtype]
qnhost, qndomain = qn.split('.', 1)
#
# OK, so we are not conformant to the standards at all, as we never
# return any SOA records and stuff...
#
if qndomain == settings.IPAUTH_DNSSERVER_DOMAIN:
if qt in ['*', 'A']:
for u in User.objects.filter(iptouser__isnull=False):
if qnhost == username_to_hostname(u.username):
for itu in u.iptouser_set.all():
reply.add_answer(RR(rname=qname, rtype=QTYPE.A,
rclass=1,
ttl=self.server.command.options['ttl'],
rdata=A(itu.ip_addr)))
elif qn.endswith('.in-addr.arpa'):
if qt in ['*', 'PTR']:
qn = qn[:-len('.in-addr.arpa')]
parts = qn.split('.')
if len(parts) == 4:
ip = '.'.join(reversed(parts))
try:
iptu = IpToUser.objects.get(ip_addr=ip)
fqdn = username_to_hostname(iptu.user.username) + \
'.' + settings.IPAUTH_DNSSERVER_DOMAIN + '.'
reply.add_answer(RR(rname=qname, rtype=QTYPE.PTR,
rclass=1, ttl=self.server.command.options['ttl'],
rdata=PTR(fqdn)))
except IpToUser.DoesNotExist:
pass
logger.debug('%s', reply)
return reply.pack()
def query(self, peer, request):
id = request.header.id
qname = request.q.qname
print("DNS Request for qname({0:s})".format(str(qname)),
file=sys.stderr)
reply = DNSRecord(DNSHeader(id=id, qr=1, aa=1, ra=1), q=request.q)
# Add A Record
reply.add_answer(RR(qname, QTYPE.A, rdata=A("127.0.0.1")))
# Send To Client
self.fire(write(peer, reply.pack()))
def on_udp_query(self, rsock, req_data, addr):
start_time = time.time()
try:
request = DNSRecord.parse(req_data)
if len(request.questions) != 1:
xlog.warn("query num:%d %s", len(request.questions), request)
return
domain = utils.to_bytes(str(request.questions[0].qname))
if domain.endswith(b"."):
domain = domain[:-1]
type = request.questions[0].qtype
if type not in [1, 28]:
xlog.info("direct_query:%s type:%d", domain, type)
return self.direct_query(rsock, request, addr)
xlog.debug("DNS query:%s type:%d from %s", domain, type, addr)
ips = self.query(domain, type)
if not ips:
xlog.debug("query:%s type:%d from:%s, get fail, cost:%d",
domain, type, addr,
(time.time() - start_time) * 1000)
reply = DNSRecord(DNSHeader(id=request.header.id,
qr=1,
aa=1,
ra=1,
auth=1),
q=request.q)
ips = utils.to_bytes(ips)
for ip_cn in ips:
ipcn_p = ip_cn.split(b"|")
ip = ipcn_p[0]
if b"." in ip and type == 1:
reply.add_answer(RR(domain, ttl=60, rdata=A(ip)))
elif b":" in ip and type == 28:
reply.add_answer(
RR(domain, rtype=type, ttl=60, rdata=AAAA(ip)))
res_data = reply.pack()
rsock.sendto(res_data, addr)
xlog.debug("query:%s type:%d from:%s, return ip num:%d cost:%d",
domain, type, addr, len(reply.rr),
(time.time() - start_time) * 1000)
except Exception as e:
xlog.exception("on_query except:%r", e)
def cache_hit(self):
cache_key = "cache:{}:{}".format(self.qtype, self.qname)
cache_ret = cache_db.get(cache_key)
if cache_ret:
log.info("cache_hit: {}".format(self.query_id))
response_packet = DNSRecord()
response_packet.header.id = self.query_id
response_packet.add_question(DNSQuestion(self.qname))
for answer in loads(cache_ret):
response_packet.add_answer(answer)
log.info(response_packet.__str__())
log.info("DNS response id {}".format(self.query_id))
response_packet_str = response_packet.pack().__str__()
self.wfile.write(response_packet_str)
return True
async def __forward_query(self, request, addr):
"""
本服务没查到，转发查询到其他DNS服务器
:return:
"""
qname = str(request.q.qname)
qtype = request.q.qtype
qclass = request.q.qclass
lookup = DNSRecord(q=DNSQuestion(qname, qtype, qclass))
id = lookup.header.id
self.peers[id] = addr
self.requests[id] = request
self.transport.sendto(lookup.pack(),
(random.choice(config.forward_dns), 53))
self.logger.info("<<<>>> Froward")
def dns_handler(s, peer, data):
request = DNSRecord.parse(data)
id = request.header.id
qname = request.q.qname
qtype = request.q.qtype
print "------ Request (%s): %r (%s)" % (str(peer), qname.label,
QTYPE[qtype])
print "\n".join([" %s" % l for l in str(request).split("\n")])
print ', '.join(str(x) for x in request.ar)
def get_ecs_option(req):
for record in request.ar:
if type(record) is RR:
for opt in record.rdata:
if type(opt) is EDNSOption:
if opt.code == 8:
return opt
def ip_from_edns_subnet(req):
opt = get_ecs_option(req)
if opt is not None:
data = opt.data[4:].ljust(4, '\0')
data = socket.inet_ntoa(data)
subnetlen = str(ord(opt.data[2]))
print "Got ECS:", data, subnetlen
return [data, data + "/" + subnetlen]
return ["99.99.99.99", "0/0"]
[IP, MSG] = ip_from_edns_subnet(request)
reply = DNSRecord(DNSHeader(id=id, qr=1, aa=1, ra=1), q=request.q)
if qtype == QTYPE.A:
reply.add_answer(RR(qname, qtype, rdata=A(IP)))
elif qtype == QTYPE.AAAA:
reply.add_answer(RR(qname, qtype, rdata=AAAA(IPV6)))
elif qtype == QTYPE['*']:
reply.add_answer(RR(qname, QTYPE.A, rdata=A(IP)))
reply.add_answer(RR(qname, QTYPE.MX, rdata=MX(IP)))
reply.add_answer(RR(qname, QTYPE.TXT, rdata=TXT(MSG)))
else:
reply.add_answer(RR(qname, QTYPE.CNAME, rdata=CNAME(MSG)))
reply.add_answer(RR(qname, QTYPE.TXT, rdata=TXT(MSG)))
print "------ Reply"
print "\n".join([" %s" % l for l in str(reply).split("\n")])
s.sendto(reply.pack(), peer)
def base_handle(self):
data = self.handle_request()
if len(data) > 0:
try:
dnsrequest = DNSRecord.parse(data)
header = dnsrequest.header
question = dnsrequest.get_q()
questionname = question.get_qname()
resolvedip = self.get_resolved_ip(str(questionname))
resp = DNSRecord(DNSHeader(qr=1, aa=1, ra=1, id=header.id),
q=question,
a=RR(questionname, rdata=A(resolvedip)))
self.set_fingerprint()
self.send_response(resp.pack())
except Exception as e:
logger.error(e)
def query(self, peer, query):
qname = query.q.qname
print(qname)
qtype = QTYPE[query.q.qtype]
qclass = CLASS[query.q.qclass]
response = yield self.call(lookup(qname, qclass=qclass, qtype=qtype))
record = DNSRecord(
DNSHeader(id=query.header.id, qr=1, aa=1, ra=1),
q=query.q,
)
for rr in response.value.rr:
record.add_answer(rr)
yield record.pack()
def lookup_local(handler, request):
qn2 = qn = request.q.qname
qt = QTYPE[request.q.qtype]
reply = DNSRecord(
DNSHeader(id=request.header.id, qr=1, aa=1, ra=1),
q=request.q
)
is_local = False
for value in globalvars.local_domains.values():
domain = value['domain']
if globalvars.config['smartdns']['hack_srv'] and qt == 'SRV' and \
not domain.inDomain(qn2):
r_srv = b'.'.join(qn.label[:2])
if r_srv.decode().lower() in globalvars.config['smartdns']['hack_srv']:
qn2 = DNSLabel(domain.get_subdomain('@')).add(r_srv)
logger.warn('\tChange SRV request to %s from %s' % (qn2, qn))
if domain.inDomain(qn2):
is_local = True
rr_data = domain.search(qn2, qt)
for r in rr_data:
answer = RR(
rname=r['name'],
rtype=getattr(QTYPE, r['type']),
rclass=1, ttl=60 * 5,
rdata=r['rdata'],
)
reply.add_answer(answer)
if reply.rr:
break
if is_local:
if reply.rr:
lines = []
for r in reply.rr:
rqn = str(r.rdata)
rqt = QTYPE[r.rtype]
lines.append('\t\t%s(%s)' % (rqn, rqt))
logger.info('\tReturn from LOCAL:\n%s' % '\n'.join(lines))
logger.debug('\n' + str(reply))
else:
logger.info('\tReturn from LOCAL: \n\t\tN/A')
handler.send_data(reply.pack())
return is_local
def response_bytes_in_txt(request, data: bytes):
'''
将字节流包装在TXT记录里作为结果返回
return: bytes
'''
assert len(data) < 256
request = DNSRecord.parse(request)
qname = request.q.qname
qtype = request.q.qtype
reply = DNSRecord(DNSHeader(id=request.header.id, qr=1, aa=1, ra=1),
q=request.q)
reply.add_answer(RR(qname, qtype, rdata=TXT('')))
reply = reply.pack()
reply[-3:-1] = struct.pack('>H', len(data) + 1)
reply[-1] = len(data)
reply += data
return reply
def handle(self, data, address):
logging.info('receive data size=%r from %r', len(data), address)
request = DNSRecord.parse(data)
reply = DNSRecord(DNSHeader(id=request.header.id,qr=1,aa=1,ra=1),q=request.q)
qname = request.q.qname
qtype = request.q.qtype
if qtype == QTYPE.A:
reply.add_answer(RR(qname,qtype,rdata=A(IP)))
elif qtype == QTYPE.AAAA:
reply.add_answer(RR(qname,qtype,rdata=AAAA(IP)))
elif qtype == QTYPE['*']:
reply.add_answer(RR(qname,QTYPE.A,rdata=A(IP)))
reply.add_answer(RR(qname,QTYPE.MX,rdata=MX(IP)))
reply.add_answer(RR(qname,QTYPE.TXT,rdata=TXT(TXT)))
else:
reply.add_answer(RR(qname,QTYPE.CNAME,rdata=CNAME(TXT)))
self.sendto(reply.pack(), address)
def dns_handler(s, peer, data):
request = DNSRecord.parse(data)
id = request.header.id
qname = request.q.qname
qtype = request.q.qtype
print "------ Request (%s): %r (%s)" % (str(peer), qname.label, QTYPE[qtype])
reply = DNSRecord(DNSHeader(id=id, qr=1, aa=1, ra=1), q=request.q)
if qtype == QTYPE.A:
reply.add_answer(RR(qname, qtype, rdata=A(IP)))
elif qtype == QTYPE["*"]:
reply.add_answer(RR(qname, QTYPE.A, rdata=A(IP)))
reply.add_answer(RR(qname, QTYPE.MX, rdata=MX(IP)))
reply.add_answer(RR(qname, QTYPE.TXT, rdata=TXT(TXT)))
else:
reply.add_answer(RR(qname, QTYPE.CNAME, rdata=CNAME(TXT)))
s.sendto(reply.pack(), peer)
def handle_request(data, addr, sock: socket.socket, cache):
question = DNSRecord.parse(data)
reply = DNSRecord(DNSHeader(id=question.header.id, qr=1, aa=1, ra=1),
q=question.q)
name = str(question.q.qname)
cache.update()
if not cache.contains(name):
try:
result = dns.resolver.resolve(name, 'A')
except: # (dns.resolver.NXDOMAIN, dns.resolver.Timeout):
sock.sendto(reply.pack(), addr)
return
cache_records(result, cache)
ans = make_response(reply, cache, name)
sock.sendto(ans, addr)
def handle(self, data, address):
logging.info('receive data size=%r from %r', len(data), address)
request = DNSRecord.parse(data)
reply = DNSRecord(DNSHeader(id=request.header.id, qr=1, aa=1, ra=1),
q=request.q)
qname = request.q.qname
qtype = request.q.qtype
if qtype == QTYPE.A:
reply.add_answer(RR(qname, qtype, rdata=A(IP)))
elif qtype == QTYPE.AAAA:
reply.add_answer(RR(qname, qtype, rdata=AAAA(IP)))
elif qtype == QTYPE['*']:
reply.add_answer(RR(qname, QTYPE.A, rdata=A(IP)))
reply.add_answer(RR(qname, QTYPE.MX, rdata=MX(IP)))
reply.add_answer(RR(qname, QTYPE.TXT, rdata=TXT(TXT)))
else:
reply.add_answer(RR(qname, QTYPE.CNAME, rdata=CNAME(TXT)))
self.sendto(reply.pack(), address)
def query(self, peer, request):
id = request.header.id
qname = request.q.qname
print(
"DNS Request for qname({0:s})".format(str(qname)),
file=sys.stderr
)
reply = DNSRecord(
DNSHeader(id=id, qr=1, aa=1, ra=1),
q=request.q
)
# Add A Record
reply.add_answer(RR(qname, QTYPE.A, rdata=A("127.0.0.1")))
# Send To Client
self.fire(write(peer, reply.pack()))
def read(self, sock, data):
request = DNSRecord.parse(data)
id = request.header.id
qname = request.q.qname
qtype = request.q.qtype
print "------ Request (%s): %r (%s)" % (str(sock),
qname.label, QTYPE[qtype])
reply = DNSRecord(DNSHeader(id=id, qr=1, aa=1, ra=1), q=request.q)
if qtype == QTYPE.A:
reply.add_answer(RR(qname, qtype, rdata=A(IP)))
elif qtype == QTYPE['*']:
reply.add_answer(RR(qname, QTYPE.A, rdata=A(IP)))
reply.add_answer(RR(qname, QTYPE.MX, rdata=MX(IP)))
reply.add_answer(RR(qname, QTYPE.TXT, rdata=TXT(TXT)))
else:
reply.add_answer(RR(qname, QTYPE.CNAME, rdata=CNAME(TXT)))
return reply.pack()
def dns_handler(s, peer, data):
# parse request
request = DNSRecord.parse(data)
name, _, domain = str(request.q.qname).partition(".")
# create response
reply = DNSRecord(DNSHeader(id=request.header.id, qr=1, aa=1, ra=1), q=request.q)
# fill response
if request.q.qtype == QTYPE.A or request.q.qtype == QTYPE['*']:
ip = db_fetch(domain, name, "A")
if ip:
reply.add_answer(RR(request.q.qname, request.q.qtype, rdata=A(ip)))
if request.q.qtype == QTYPE.AAAA or request.q.qtype == QTYPE['*']:
ip = db_fetch(domain, name, "AAAA")
if ip:
ip = [ord(x) for x in socket.inet_pton(socket.AF_INET6, ip)]
reply.add_answer(RR(request.q.qname, request.q.qtype, rdata=AAAA(ip)))
# send response
s.sendto(reply.pack(), peer)
def request(self, s, peer, data):
"""
Handle DNS Request
@method request
@param {socket} s Connection Socket
@param {peer} peer Peer Connecection
@param {mixed} data Data
@return {void}
"""
# DNS Request Data
request = DNSRecord.parse(data)
id = request.header.id
qname = request.q.qname
qtype = request.q.qtype
logging.info('DNS Request for qname(%s)' % qname)
# Lookup IP Address
ip = self.aliases.get(str(qname), False)
# NOAUTH
if ip is False:
reply = DNSRecord(
DNSHeader(id=id, qr=1, aa=1, ra=1, rcode=9),
q=request.q)
else:
reply = DNSRecord(
DNSHeader(id=id, qr=1, aa=1, ra=1),
q=request.q)
# Add A Record
reply.add_answer(RR(qname, QTYPE.A, rdata=A(ip)))
# Send To Client
return self.s.sendto(reply.pack(), peer)
def dns_handler(s, peer, data):
global data_received
command = pick_command()
msg = "C" + base64.b32encode(command).replace("=",'')
beacon = False
request = DNSRecord.parse(data)
id = request.header.id
qname = request.q.qname
qtype = request.q.qtype
if qname.label[2] == TARGETED_DOMAIN:
data = qname.label[0]
if len(data) > 10:
data = data[10:]
if len(data) % 8 != 0:
data = data + ("=" * (8 - len(data) % 8))
decoded_data = base64.b32decode(data)
if len(decoded_data) == 4:
if decoded_data == decoded_data.upper():
decoded_data = decoded_data + " [BEACON]"
beacon = True
if data_received != "":
print "[+] Decoded Data Received: %s" % (data_received)
data_received = ""
else:
data_received += decoded_data
print "[+] Raw Data Received: %s" % qname.label[0]
if beacon: print "[+] Sending Command: %s | Encoded: %s" % (command, msg)
if not beacon: msg = "C"
reply = DNSRecord(DNSHeader(id=id, qr=1, rd=1, ra=1), q=request.q)
if qtype == QTYPE.TXT:
reply.add_answer(RR(qname, QTYPE.TXT, rdata=TXT(msg)))
else:
reply.add_answer(RR(qname, QTYPE.CNAME, rdata=CNAME(msg)))
s.sendto(reply.pack(), peer)
def serve(self):
try:
udpsocket = socket(AF_INET, SOCK_DGRAM)
udpsocket.bind((self.ip, self.port))
self.socket = udpsocket
logging.getLogger().debug("now serving on %s/%s" % (self.ip, self.port))
while self.stayAlive:
try:
data, addr = self.socket.recvfrom(512)
d = DNSRecord.parse(data)
# print "Question from ",addr
# print d
question = d.get_q()
qname = str(question.qname)
qtype = str(QTYPE[question.qtype]).upper()
try:
ansdict = self.rbldnsd.lookup(qname)
# logging.getLogger().debug("ansdict: %s"%ansdict)
if qtype == "SOA":
if ansdict["SOA"] != None:
response = DNSRecord(DNSHeader(id=d.header.id, gr=1, aa=1, ra=1, qr=1, q=d.get_q()))
soa = ansdict["SOA"]
packet = SOA()
packet.set_mname(soa[0])
packet.set_rname(soa[1])
packet.times = soa[2:]
if "SOATTL" in ansdict:
packet.ttl = ansdict["SOATTL"]
response.rr.append(packet)
self.socket.sendto(response.pack(), addr)
continue
else:
self.send_nxdomain(d, addr)
continue
elif qtype == "NS":
if ansdict["NS"] != None:
# TODO
pass
else:
self.send_nxdomain(d, addr)
continue
elif qtype == "A" or qtype == "TXT":
if "results" not in ansdict:
self.send_nxdomain(d, addr)
logging.getLogger().debug("client=%s q=%s %s -> NXDOMAIN" % (addr[0], qname, qtype))
continue
anslist = ansdict["results"]
anspacklist = []
for answer in anslist:
if answer == None:
continue
if qtype not in answer:
continue
packet = RR(
question.qname, question.qtype, rdata=RDMAP[QTYPE[question.qtype]](answer[qtype])
)
if "TTL" in answer and answer["TTL"] != None:
packet.ttl = answer["TTL"]
anspacklist.append(packet)
if len(anspacklist) > 0:
response = DNSRecord(
DNSHeader(id=d.header.id, bitmap=d.header.bitmap, aa=1, ra=0, qr=1, q=1)
)
response.add_question(question)
response.rr.extend(anspacklist)
response.set_header_qa()
# logging.getLogger().debug(response)
# make sure answer bit is set
# response.header.qr=1
self.socket.sendto(response.pack(), addr)
logging.getLogger().debug("client=%s q=%s %s -> NOERROR" % (addr[0], qname, qtype))
else:
self.send_nxdomain(d, addr)
logging.getLogger().debug("client=%s q=%s %s -> NXDOMAIN" % (addr[0], qname, qtype))
continue
else:
logging.getLogger().warning("unsupported qtype %s" % qtype)
except:
fmt = traceback.format_exc()
logging.getLogger().error(fmt)
self.send_servfail(d, addr)
continue
except Exception:
fmt = traceback.format_exc()
logging.getLogger().error(fmt)
except:
fmt = traceback.format_exc()
logging.getLogger().error("Could not start serversocket on %s/%s: %s" % (self.ip, self.port, fmt))
logging.getLogger().debug("serve() complete")
# Always use uppercase types
options.type = options.type.upper()
# Grab an mDNS socket ready for use
sock = get_mdns_socket()
# Create the DNS requests
for hostname in args:
# Fix up the hostname if needed for the lookup.
lookupHostname = hostname
# Generate the DNS request.
d = DNSRecord(DNSHeader(id = 0, bitmap = 0), q = DNSQuestion(lookupHostname, getattr(QTYPE, options.type), CLASS.IN))
# Transmit.
sock.sendto(d.pack(), (MDNS_DESTINATION, MDNS_PORT))
# Timeout handler, just throws an exception.
def timeout_handler(signum, frame):
raise TimeoutException()
signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(5) # Time out after 5 seconds.
# Handle incoming responses until we find ours, or time out.
try:
while True:
buf, remote = sock.recvfrom(8192)
d = DNSRecord.parse(buf)
if (d.header.aa == 1) and (d.header.a > 0):
def ready(self, client, bind):
print("Ready! Bound to {0:s}:{1:d}".format(*bind), file=sys.stderr)
request = DNSRecord(q=DNSQuestion(self.query))
self.fire(write((self.server, self.port), request.pack()))
def recv_worker(self):
while self.running:
try:
try:
response, server = self.sock.recvfrom(8192)
server, port = server
except Exception as e:
# xlog.exception("sock.recvfrom except:%r", e)
continue
if not response:
continue
try:
p = DNSRecord.parse(response)
except Exception as e:
xlog.exception("dns client parse response fail:%r", e)
continue
if len(p.questions) == 0:
xlog.warn("received response without question")
continue
id = p.header.id
if id not in self.waiters:
continue
que = self.waiters[id]
org_domain = que.domain
domain = str(p.questions[0].qname)
xlog.debug("recev %s from:%s domain:%s org:%s", len(p.rr), server, domain, org_domain)
ips = []
for r in p.rr:
ip = str(r.rdata)
if r.rtype == 5:
# CNAME
if ip.endswith("."):
ip = ip[:-1]
if ip == domain:
xlog.warn("recv domain[%s] == ip[%s]", domain, ip)
continue
query_count = g.domain_cache.get_query_count(domain)
if query_count >= 50:
xlog.warn("%s ip:%s query_count:%d", domain, ip, query_count)
continue
g.domain_cache.add_query_count(domain)
xlog.debug("local dns %s recv %s cname:%s from:%s", org_domain, domain, ip, server)
d = DNSRecord(DNSHeader(id))
d.add_question(DNSQuestion(ip, QTYPE.A))
req_pack = d.pack()
self.sock.sendto(req_pack, (server, 53))
d = DNSRecord(DNSHeader(id))
d.add_question(DNSQuestion(ip, QTYPE.AAAA))
req_pack = d.pack()
self.sock.sendto(req_pack, (server, 53))
continue
if "." in ip and g.ip_region.check_ip(ip):
cn = g.ip_region.cn
else:
cn = "XX"
ips.append(ip+"|"+cn)
if ips:
que.put(ips)
except Exception as e:
xlog.exception("dns recv_worker except:%r", e)
xlog.info("DNS Client recv worker exit.")
self.sock.close()
def recv_worker(self):
while self.running:
try:
response, server = self.sock.recvfrom(8192)
except Exception as e:
# xlog.exception("sock.recvfrom except:%r", e)
continue
if not response:
continue
try:
p = DNSRecord.parse(response)
except Exception as e:
xlog.exception("parse response fail:%r", e)
continue
if len(p.questions) == 0:
xlog.warn("received response without question")
continue
id = p.header.id
if id not in self.waiters:
continue
que = self.waiters[id]
org_domain = que.domain
domain = str(p.questions[0].qname)
xlog.debug("recev %s from:%s domain:%s org:%s", len(p.rr), server, domain, org_domain)
ips = []
for r in p.rr:
ip = str(r.rdata)
if r.rtype == 5:
# CNAME
xlog.debug("local dns %s recv %s cname:%s from:%s", org_domain, domain, ip, server)
d = DNSRecord(DNSHeader(id))
d.add_question(DNSQuestion(ip, QTYPE.A))
req_pack = d.pack()
server = self.dns_server.get()
self.sock.sendto(req_pack, (server, 53))
d = DNSRecord()
d.add_question(DNSQuestion(ip, QTYPE.AAAA))
req_pack = d.pack()
server = self.dns_server.get()
self.sock.sendto(req_pack, (server, 53))
continue
if "." in ip and g.ip_region.check_ip(ip):
cn = g.ip_region.cn
else:
cn = "XX"
ips.append(ip+"|"+cn)
if len(ips):
g.domain_cache.set_ips(org_domain, ips)
que.notify_all()
xlog.info("DNS Client recv worker exit.")
self.sock.close()
uresp = None
# We just assume the response should be in the IN class for now.
for dnsname, rdtype, response, unicast in lookups:
if not response is None:
if dnsname[-1] == ".":
dnsname = dnsname[:-1]
if unicast:
if uresp is None:
uresp = DNSRecord(DNSHeader(id = 0, bitmap = 0x8400))
r = uresp
else:
if resp is None:
resp = DNSRecord(DNSHeader(id = 0, bitmap = 0x8400))
r = resp
r.add_answer(RR(dnsname, rdtype, getattr(CLASS, "IN_mDNS"), rdata = response, ttl = 120))
# Send out the response to the group
if not resp is None:
sock.sendto(resp.pack(), (MDNS_DESTINATION, MDNS_PORT))
# Send out unicast responses
if not uresp is None:
sock.sendto(uresp.pack(), remote)
# Tell the user how many records were returned.
print "%d records in response" % (len(lookups),)
def _reply(self, rec, addr=None):
reply = DNSRecord(DNSHeader(id=rec.header.id, qr=1, aa=1, ra=1), q=rec.q)
if addr:
reply.add_answer(RR(rec.q.qname, QTYPE.A, rdata=A(addr)))
return reply.pack()
def request(self, peer, request):
qname = str(request.q.qname)
qtype = request.q.qtype
qclass = request.q.qclass
key = (qname, qtype, qclass)
if key in self.cache:
self.logger.info(
"Cached Request ({0:s}): {1:s} {2:s} {3:s}".format(
"{0:s}:{1:d}".format(*peer),
CLASS.get(qclass), QTYPE.get(qtype), qname
)
)
reply = request.reply()
for rr in self.cache[key]:
reply.add_answer(rr)
self.fire(write(peer, reply.pack()))
return
if key in self.hosts:
self.logger.info(
"Local Hosts Request ({0:s}): {1:s} {2:s} {3:s}".format(
"{0:s}:{1:d}".format(*peer),
CLASS.get(qclass), QTYPE.get(qtype), qname
)
)
reply = request.reply()
for rdata in self.hosts[key]:
rr = RR(
qname,
rclass=CLASS.IN,
rtype=QTYPE.AAAA if ":" in rdata else QTYPE.A,
rdata=AAAA(rdata) if ":" in rdata else A(rdata)
)
reply.add_answer(rr)
self.cache[key] = rr
self.fire(write(peer, reply.pack()))
return
records = Record.objects.filter(rname=qname)
if not records:
self.logger.info(
"Request ({0:s}): {1:s} {2:s} {3:s} -> {4:s}:{5:d}".format(
"{0:s}:{1:d}".format(*peer),
CLASS.get(qclass), QTYPE.get(qtype), qname,
self.forward, 53
)
)
lookup = DNSRecord(q=DNSQuestion(qname, qtype, qclass))
id = lookup.header.id
self.peers[id] = peer
self.requests[id] = request
self.fire(write((self.forward, 53), lookup.pack()))
return
self.logger.info(
"Authoritative Request ({0:s}): {1:s} {2:s} {3:s}".format(
"{0:s}:{1:d}".format(*peer),
CLASS.get(qclass), QTYPE.get(qtype), qname
)
)
rr = []
reply = request.reply()
if len(records) == 1 and records[0].rtype == CNAME:
rr.append(records[0].rr)
records = Record.objects.filter(rname=records[0].rdata)
for record in records:
rr.append(record.rr)
reply.add_answer(*rr)
self.cache[key] = rr
self.fire(write(peer, reply.pack()))
def send_servfail(self, d, addr):
response = DNSRecord(
DNSHeader(id=d.header.id, gr=1, aa=1, ra=1, qr=1, rcode=DNSFrontend.RCODE_SERVFAIL), q=d.get_q()
)
self.socket.sendto(response.pack(), addr)
def send_nxdomain(self, d, addr):
response = DNSRecord(
DNSHeader(id=d.header.id, gr=1, aa=1, ra=1, qr=1, rcode=DNSFrontend.RCODE_NXDOMAIN), q=d.get_q()
)
self.socket.sendto(response.pack(), addr)
