def _extractClientInformation(self, msg): power = msg.get("power") mid = msg.get("mid") pid = msg.get("pid") if power is None: self._sendError("I need your computing power") raise Exception("Newly connected client did not send " "it's computing power value, sending back " "the error message") if mid is None: self._sendError("I need your machine id") raise Exception("Newly connected client did not send " "it's machine id, sending back the error " "message") if pid is None: self._sendError("I need your process id") raise Exception("Newly connected client did not send " "it's process id, sending back the error " "message") self.nodes[self.id] = { "power": power, "mid": mid, "pid": pid, "id": self.id, "jobs": 0, "backend": msg.get("backend"), "device": msg.get("device"), "argv": msg.get("argv"), "executable": msg.get("executable"), "PYTHONPATH": msg.get("PYTHONPATH"), "cwd": msg.get("cwd")} dns.lookupPointer( ".".join(reversed(self.addr.host.split("."))) + ".in-addr.arpa") \ .addCallback(self._resolveAddr).addErrback(self._failToResolveAddr) return power, mid, pid
def lookupAndVerifyPTR(ip, *args, **kwargs): d = defer.Deferred() ipobj = ip_address(unicode(ip)) if ipobj.version == 4: ipver = AF_INET else: ipver = AF_INET6 def recvd_ptr(result): answer, auth, additional = result if len(answer) != 1: raise LookupException( "Not exactly one answer in PTR response for %s" % ip) hostname = str(answer[0].payload.name) def recvd_addr(result): answers, auth, additional = result if not answers: raise LookupException("No answers in A/AAAA response for %s" % hostname) addresses = [ inet_ntop(ipver, answer.payload.address) for answer in answers ] if ip not in addresses: raise VerificationException( "IP mismatch: %s is not in %s (%s)" % (ip, repr(addresses), hostname)) d.callback(hostname) if ipobj.version == 4: client.lookupAddress(hostname, *args, **kwargs).addCallback(recvd_addr).addErrback( d.errback) else: client.lookupIPV6Address( hostname, *args, **kwargs).addCallback(recvd_addr).addErrback(d.errback) client.lookupPointer(ipobj.reverse_pointer, *args, **kwargs).addCallback(recvd_ptr).addErrback(d.errback) return d
def test_lookupPointer(self): """ See L{test_lookupAddress} """ d = client.lookupPointer(self.hostname) d.addCallback(self.checkResult, dns.PTR) return d
def __init__(self, blacklist): super(ManagerBlacklistDialog, self).__init__() uic.loadUi('manager_blacklist.ui', self) self.blacklist = blacklist #self.addr_list.cellDoubleClicked.connect(self.select_ip) self.actionAllow.clicked.connect(self.allow_ip) self.actionDeny.clicked.connect(self.deny_ip) self.insert.clicked.connect(self.insert_ip) self.remove.clicked.connect(self.remove_ip) self.addr_list.setColumnWidth(1, 120) self.addr_list.setColumnWidth(0, 50) for idx, (IP, netsize, hostname, allow) in enumerate(self.blacklist.items): self.addr_list.insertRow(idx) self.addr_list.setItem(idx, 0, QtGui.QTableWidgetItem(str(allow))) self.addr_list.setItem(idx, 1, QtGui.QTableWidgetItem("%s/%s" % (IP, netsize) )) if netsize > 32: self.addr_list.setItem(idx, 2, QtGui.QTableWidgetItem("<Network>")) elif hostname: self.addr_list.setItem(idx, 2, QtGui.QTableWidgetItem(hostname)) else: self.addr_list.setItem(idx, 2, QtGui.QTableWidgetItem("<resolving>")) record_name = ".".join(IP.split(".")[::-1]) + ".in-addr.arpa" print "looking up IP address %s" % (record_name,) d = nameclient.lookupPointer(record_name) d.addCallbacks(callback = self.update_name, errback = self.name_error, callbackArgs = (idx,), errbackArgs = (idx,))
def main(reactor): pending = [] for addr in IPNetwork('79.170.40.0/24'): d = client.lookupPointer(addr.reverse_dns, timeout=(1,)) pending.append(d) return defer.DeferredList(pending, consumeErrors=True).addCallback(printResult)
def resolve_name(self): #try: # self.hostname = socket.gethostbyaddr(self.ip_addr)[0] #except socket.herror: # self.hostname = "Unknown" self.d = client.lookupPointer(name=self.reverse_name_for_ip_address()) self.d.addCallback(self.lookup_ptr_callback) return self.d
def _taskGenerator(self): for ip in self.ips: addr = ip ptr = IPy.IP(addr).reverseName() d = client.lookupPointer(ptr, timeout=self.timeouts ).addCallback(lambda x, addr=addr: self._lookupSuccess(x, addr) ).addErrback(lambda x, addr=addr: self._lookupError(x, addr)) yield d
def _reverse_IPv4_lookup(self, ipString): """ @param ipString: dotted-quad IP address. """ parts = ipString.split('.') parts.reverse() host = '.'.join(parts) + '.in-addr.arpa' return lookupPointer(host).addCallback(self._gotReverseLookupResult)
def _startDNSResolving(self, timeout): ip = self.ip if ipIsV4(ip): addr = "{}.in-addr.arpa".format(".".join(reversed(ip.split(".")))) else: addr = reversed(expandIPv6Address(ip).replace(":", "")) addr = "{}.ip6.arpa".format(".".join(addr)) resolveDeferred = dnsClient.lookupPointer(addr, ((timeout/2),)) resolveDeferred.addCallbacks(callback=self._verifyDNSResolution, callbackArgs=(timeout,), errback=self._cancelDNSResolution)
def lookupPTR(ip, *args, **kwargs): def callback(result): answer, auth, add = result if len(answer) == 0: raise LookupException, "No ANSWERS in PTR response for %s." % repr(ip) return str(answer[0].payload.name) ptr = ".".join(ip.split(".")[::-1]) + ".in-addr.arpa." return client.lookupPointer(ptr, **kwargs).addCallback(callback)
def lookupAndVerifyPTR(ip, *args, **kwargs): d = defer.Deferred() ipobj = ip_address(unicode(ip)) if ipobj.version == 4: ipver = AF_INET else: ipver = AF_INET6 def recvd_ptr(result): answer, auth, additional = result if len(answer) != 1: raise LookupException("Not exactly one answer in PTR response for %s" % ip) hostname = str(answer[0].payload.name) def recvd_addr(result): answers, auth, additional = result if not answers: raise LookupException("No answers in A/AAAA response for %s" % hostname) addresses = [ inet_ntop(ipver, answer.payload.address) for answer in answers ] if ip not in addresses: raise VerificationException("IP mismatch: %s is not in %s (%s)" % (ip, repr(addresses), hostname)) d.callback(hostname) if ipobj.version == 4: client.lookupAddress(hostname, *args, **kwargs).addCallback(recvd_addr).addErrback(d.errback) else: client.lookupIPV6Address(hostname, *args, **kwargs).addCallback(recvd_addr).addErrback(d.errback) client.lookupPointer(ipobj.reverse_pointer, *args, **kwargs).addCallback(recvd_ptr).addErrback(d.errback) return d
def lookupPTRv6(ip, *args, **kwargs): def callback(result): answer, auth, add = result answer = [x for x in answer if x.type == dns.PTR] if len(answer) == 0: raise LookupException("No ANSWERS in PTR response for %s." % repr(ip)) return str(answer[0].payload.name) ptr = ".".join(reversed(expandIPv6(ip))) + ".ip6.arpa." return client.lookupPointer(ptr, **kwargs).addCallback(callback)
def _startDNSResolving(self, timeout): ip = self.ip if ipIsV4(ip): addr = "{}.in-addr.arpa".format(".".join(reversed(ip.split(".")))) else: addr = reversed(expandIPv6Address(ip).replace(":", "")) addr = "{}.ip6.arpa".format(".".join(addr)) resolveDeferred = dnsClient.lookupPointer(addr, ((timeout / 2), )) resolveDeferred.addCallbacks(callback=self._verifyDNSResolution, callbackArgs=(timeout, ), errback=self._cancelDNSResolution)
def lookupPTR(ip, *args, **kwargs): def callback(result): answer, auth, add = result if len(answer) == 0: raise LookupException, "No ANSWERS in PTR response for %s." % repr( ip) return str(answer[0].payload.name) ptr = ".".join(ip.split(".")[::-1]) + ".in-addr.arpa." return client.lookupPointer(ptr, **kwargs).addCallback(callback)
def reversedns(self, addr): """ Perform a reverse DNS lookup on an IP Arguments: addr -- IPv4 Address """ try: ptr = ipaddress.ip_address(addr).reverse_pointer except ValueError: return None d = client.lookupPointer(ptr, timeout=self.timeout) return d
def _extractClientInformation(self, msg): power = msg.get("power") mid = msg.get("mid") pid = msg.get("pid") if power is None: self._sendError("I need your computing power") raise Exception("Newly connected client did not send " "it's computing power value, sending back " "the error message") if mid is None: self._sendError("I need your machine id") raise Exception("Newly connected client did not send " "it's machine id, sending back the error " "message") if pid is None: self._sendError("I need your process id") raise Exception("Newly connected client did not send " "it's process id, sending back the error " "message") self.nodes[self.id] = { "power": power, "mid": mid, "pid": pid, "id": self.id, "jobs": 0, "backend": msg.get("backend"), "device": msg.get("device"), "argv": msg.get("argv"), "executable": msg.get("executable"), "PYTHONPATH": msg.get("PYTHONPATH"), "cwd": msg.get("cwd") } dns.lookupPointer( ".".join(reversed(self.addr.host.split("."))) + ".in-addr.arpa") \ .addCallback(self._resolveAddr).addErrback(self._failToResolveAddr) return power, mid, pid
def asyncNameLookup(address, uselibcresolver = True): """ Turn IP addreses into names using deferreds """ if uselibcresolver: # This is the most reliable way to do a lookup use it return threads.deferToThread(lambda : socket.gethostbyaddr(address)[0]) else: # There is a problem with this method because it will ignore /etc/hosts address = '.'.join(address.split('.')[::-1]) + '.in-addr.arpa' d = lookupPointer(address, [1,2,4]) def ip(result): return str(result[0][0].payload.name) d.addCallback(ip) return d
def reverse_lookup(address): """This function performs the Reverse Lookup for each ip of lookup answer""" outer_deferred = defer.Deferred() def wrap_result(result): """ Wrap result returned by Twisted """ outer_deferred.callback(ReverseAnswer(result)) def wrap_error(err): """ Wrap error returned by Twisted """ outer_deferred.errback(ReverseErrors(err)) rev_ip = reverse_ip_address(address=address) inner_deferred = client.lookupPointer(rev_ip, timeout=[5, 10, 20, 30]) inner_deferred.addCallbacks(wrap_result, wrap_error) return outer_deferred
def main(reactor): hosts = readList() for host in hosts: inicio = datetime.datetime.now() if host[1] == 'A\n': d = client.getHostByName(host[0]) l = [time()] a = d.addCallback(printResult2, l) print l print a, type(a) b = d.addErrback(error, inicio) print b else: d = client.lookupPointer(name=reverseNameFromIPAddress( address=host[0])) d.addCallback(printResult, inicio) d.addErrback(error, inicio) return d
def main(reactor, *argv): options = Options() try: options.parseOptions(argv) except usage.UsageError as errortext: sys.stderr.write(str(options) + "\n") sys.stderr.write(f"ERROR: {errortext}\n") raise SystemExit(1) pending = [] for address in options["addresses"]: pointerName = reverseNameFromIPAddress(address) # Force a single 1s timeout, so that slow or offline servers don't # adversely slow down the script. result = client.lookupPointer(pointerName, timeout=(1,)) result.addCallback(printResult) pending.append(result) allResults = defer.DeferredList(pending, consumeErrors=False) allResults.addCallback(printSummary) return allResults
def main(reactor, *argv): options = Options() try: options.parseOptions(argv) except usage.UsageError as errortext: sys.stderr.write(str(options) + '\n') sys.stderr.write('ERROR: %s\n' % (errortext,)) raise SystemExit(1) pending = [] for address in options['addresses']: pointerName = reverseNameFromIPAddress(address) # Force a single 1s timeout, so that slow or offline servers don't # adversely slow down the script. result = client.lookupPointer(pointerName, timeout=(1,)) result.addCallback(printResult) pending.append(result) allResults = defer.DeferredList(pending, consumeErrors=False) allResults.addCallback(printSummary) return allResults
def add_ip(self, new_addr): print "adding host to list: %s" % (new_addr,) self.activeHost.setText('') if not new_addr: return if new_addr[0] not in "1234567890": self.add_hostname(new_addr) return new_addr, _, new_netsize = new_addr.partition('/') try: socket.inet_aton(new_addr) except Exception as e: print "Invalid IP" return new_netsize = int(new_netsize) if new_netsize else 32 for idx in range(self.addr_list.rowCount()): old_addr = str(self.addr_list.item(idx, 1).text()) old_addr, _, old_netsize = old_addr.partition('/') old_netsize = 32 if not old_netsize else int(old_netsize) if old_addr == new_addr and old_netsize == new_netsize: return idx = idx+1 self.addr_list.insertRow(idx) self.addr_list.setItem(idx, 0, QtGui.QTableWidgetItem("False")) self.addr_list.setItem(idx, 1, QtGui.QTableWidgetItem("%s/%s" % (new_addr, new_netsize) )) if new_netsize < 32: self.addr_list.setItem(idx, 2, QtGui.QTableWidgetItem("<network>")) else: self.addr_list.setItem(idx, 2, QtGui.QTableWidgetItem("<resolving>")) record_name = ".".join(new_addr.split(".")[::-1]) + ".in-addr.arpa" print "looking up IP address %s" % (record_name,) d = nameclient.lookupPointer(record_name) d.addCallbacks(callback = self.update_name, errback = self.name_error, callbackArgs = (idx,), errbackArgs = (idx,))
def main(reactor, address): d = client.lookupPointer(name=reverseNameFromIPAddress(address=address)) d.addCallback(printResult) return d
def data_dns(self, ctx, data): ptr = '.'.join(str(self.ip).split('.')[::-1]) + '.in-addr.arpa' d = client.lookupPointer(ptr) d.addErrback(lambda x: None) return d
def data_solvedip(self, ctx, ip): ptr = '.'.join(ip.split('.')[::-1]) + '.in-addr.arpa' d = client.lookupPointer(ptr) d.addErrback(lambda x: None) return d
def reverseLookup(address, outFile): d = client.lookupPointer(name=reverseNameFromIP(address), timeout=(1, 3, 5, 10)) d.addCallback(writeResult, address, outFile) d.addErrback(lookupFailed, address, outFile) return d