DNS-py2/main.py

#!/usr/bin/python2.7
#GUI REWRITE
import whois
import signal
import dns.resolver
import json
import warnings
import os
import platform
from dns import reversename
from ipwhois.net import Net
from ipwhois.asn import IPASN
from pprint import pprint
from libs import config
from libs import colours as gc
from libs import cc

# Loaded from the config file
jsonData = config.readConf("~/config.json")

subdomains = jsonData["subdomains"]
dnsrecords = jsonData["dnsrecords"]
colour_attn = gc.getColour(jsonData["colour_attn"])
colour_good = gc.getColour(jsonData["colour_good"])
colour_pretty = gc.getColour(jsonData["colour_pretty"])
colour_default = gc.getColour(jsonData["colour_default"])
CSVFile = jsonData["country_codes"]
# Endconfig block

dnsrecs = {}

if platform.system().lower() == "linux":
    import readline
else:
    colour_attn = ""
    colour_good = ""
    colour_pretty = ""
    colour_default = ""

running = 1
prompt = ': '
indent = '~ '
whoisrecs = ["NotFound", "DomainName", "Registrar", "Status", "UpdatedDate", "CreationDate", "ExpirationDate", "RegistrantName", "RegistrantEmail", "EligibilityName", "EligibilityType", "EligibilityID", "RegistrantID", "NameServer"]
ipData = {"asn_country_code":"Country", "asn_description":"Owner"}

CountryDict = cc.parseCSV(cc.openCSV(CSVFile))

def domainWhois(inData):
	whoisData = whois.whois(inData).query()
        return whois.Parser(inData, whoisData[1]).parse()

def signal_handler(singal, frame):
    quit()

def printWhois(resultData):
    for x in range(0, len(whoisrecs)):        
        try:
            for item in resultData[whoisrecs[x]]:
                if whoisrecs[x] == "Status":
                    if "ok" in item or "OK" in item:
                        print(indent + colour_good + '%s: %s' % (whoisrecs[x], item) + colour_default)
                    else:
                        print(indent + colour_attn + '%s: %s' % (whoisrecs[x], item) + colour_default)
                else:
                    print(indent + '%s: %s' % (whoisrecs[x], item))
        except Exception as e:
            pass

def cnameToA(cname):
    data = dns.resolver.query(cname, "A")
    for rdata in data:
        return rdata

def parseInput(inData):
    tmpInData = inData.lower()
    tmpInData = tmpInData.strip()
    if tmpInData == "quit":
        quit()
    if checkIfIP(tmpInData):
        lookupIP(tmpInData)
    else:
        lookupDomain(tmpInData)

def recLookup(inData):
    global dnsrecs
    for dnsrec in dnsrecords:
        try:
            data = dns.resolver.query(inData, dnsrec)
            for rdata in data:
                rdataTMP = rdata.to_text().split(" ")
                if dnsrec != "MX":
                    if dnsrec != "NS":
                        #print( indent + colour_pretty + "%s:\t%s%s" % (dnsrec, colour_good, rdata) + colour_default)
                        dnsrecs[dnsrec] = rdata
                    else:
                        tmpData = cnameToA(rdata.to_text())
                        #print( indent + colour_pretty + "%s:\t%s%s -> %s" % (dnsrec, colour_good, rdata, tmpData) + colour_default)
                        dnsrecs[dnsrec] = rdata
                else:
                    tmpData = cnameToA(rdataTMP[1])
                    #print( indent + colour_pretty + "%s:\t%s%s -> %s" % (dnsrec, colour_good, rdata, tmpData) + colour_default)
                    dnsrecs[dnsrec] = rdata
        except Exception as e:
            pass

def subLookup(inData, sub):
    global dnsrecs
    try:
        data = dns.resolver.query(sub + '.' + inData)
        for rdata in data:
            if data.qname == data.canonical_name:
                #Old function printed the result now I am returning the result, may add to a dict.
                #print(indent + colour_pretty + "%s:\t%s%s" % (sub, colour_good, rdata) + colour_default)
                dnsrecs[sub] = rdata 
            else:
                for rdata in dns.resolver.query(sub + '.' + inData, "CNAME"):
                    #print(indent + colour_pretty + "%s:\t%s%s -> %s" % (sub, colour_good, rdata, cnameToA(sub + "." + inData).to_text()) + colour_default)
                    dnsrecs[sub] = rdata
    except Exception as e:
        pass

def lookupDomain(inData):
    global dnsrecs
    dnsrecs = {}
    try:
        result = domainWhois(inData)
    except Exception as E:
        print('%s : TLD most likely needs to be configured' % (E))
        result = "Error"
    #print("\nWhois Information")
    #printWhois(result)
    #print("\nDNS Records")
    recLookup(inData)
    #print("\nSub Domains")
    for subs in subdomains:
        subLookup(inData, subs)
    return dnsrecs, result

def lookupIP(inData):
   with warnings.catch_warnings():
            warnings.filterwarnings("ignore", category=UserWarning)
            ipnet = Net(inData)
            ipobj = IPASN(ipnet)
            results = ipobj.lookup()
            for types in ipData:
                if types == "asn_country_code":
                    print(indent + "%s%s:%s\t%s%s" % (colour_pretty, ipData[types], colour_good, CountryDict[results[types]], colour_default))
                else:
                    print(indent + "%s%s:%s\t%s%s" % (colour_pretty, ipData[types], colour_good, results[types], colour_default))
            rev_name = reversename.from_address(inData)
            try:
                reverseName = str(dns.resolver.query(rev_name, "PTR")[0])
            except Exception as E:
                reverseName = E
            print('\n' + indent + '%sPTR:%s\t\t%s%s' % (colour_pretty, colour_good, reverseName, colour_default))

# Taken and modified from DNSpy 1, I am not asahmed it works
def checkIfIP(in1):
    count = 0
    inSplit = in1.split('.')
    if len(inSplit) != 4:
        return False
    for part in inSplit:
        if part.isdigit():
            count += 1
        else:
            return False
    if count == 4:
        return True

signal.signal(signal.SIGINT, signal_handler)

if __name__ == '__main__':

    while running == 1:
    	parseInput(raw_input("Please Enter a domain" + prompt) )
    	print('\n')