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)