Added DNS resolver checker + cleanups

Author: HarryR

.gitignore

@@ -1 +1,2 @@
 *.pyc
+axfr.db

README.md

@@ -12,8 +12,9 @@ was written because we knew there was a better way to do this.
  * JSON & text output
  * Progress bar
  * Tunable concurrency & timeout
+ * DNS resolver checker
 
-## Usage
+## DNSbrute Usage
 
 ```
 $ python -mdnsbrute
@@ -50,4 +51,27 @@ optional arguments:
                         Concurrent DNS requests, default: 50
   -T SECS, --timeout SECS
                         Timeout for DNS request in seconds, default: 1.5
+```
+
+### checkresolvers usage
+
+```
+$ python -mdnsbrute.checkresolvers
+usage: checkresolvers.py [-h] [-o OUTFILE] [-D] [-T SECS] [-q] [-v] [--debug]
+                         [-r RESOLVERS_FILE]
+
+DNS resolver list checker
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -o OUTFILE, --output OUTFILE
+                        Output results to file
+  -D, --download        Download new list of resolvers from public-dns.info
+  -T SECS, --timeout SECS
+                        Timeout for DNS request in seconds, default: 0.5
+  -q, --quiet           Don't print results to console
+  -v, --verbose         Log informational messages
+  --debug               Log debugging messages
+  -r RESOLVERS_FILE, --resolvers RESOLVERS_FILE
+                        Load DNS resolver servers from file
 ```

axfr/verify-axfr.py

@@ -8,11 +8,8 @@
 
 The following SQL query will provide the top 1000 most effective subdomains:
 
-    SELECT nom, GROUP_CONCAT(rec), SUM(vfy) AS total_cfy SUM(cnt) as total_cnt
-    FROM axfr_counts
-    GROUP BY nom
-    ORDER BY total_very
-    DESC LIMIT 1000;
+    SELECT nom, GROUP_CONCAT(rec), SUM(vfy) AS total_vfy, SUM(cnt) as total_cnt
+    FROM axfr_counts GROUP BY nom ORDER BY total_vfy DESC LIMIT 1000;
 """
 from __future__ import print_function
 import sys

dnsbrute/__main__.py

@@ -6,6 +6,7 @@
 from . import DNSBrute
 
 
+
 def main():
     parser = argparse.ArgumentParser(description='DNS sub-domain brute forcer')
     parser.add_argument('-p', '--progress', action='store_true',

dnsbrute/checkresolvers.py

@@ -0,0 +1,118 @@
+from __future__ import print_function
+import sys
+import argparse
+import logging
+import random
+import time
+import requests
+import pkg_resources
+import progressbar
+from dns.resolver import Resolver, Answer
+from dns.exception import DNSException
+from . import rand_name
+
+
+LOG = logging.getLogger(__name__)
+
+
+# http://stackoverflow.com/questions/287871/print-in-terminal-with-colors-using-python
+class bcolors:
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+
+
+def mean(numbers):
+    return float(sum(numbers)) / max(len(numbers), 1)
+
+
+def check_results(results):
+    avg = mean([X for X, _ in results])
+    return avg, all([isinstance(X, Answer) for _, X in results])
+
+
+def time_resolve(args, server, name, rectype, tries=3):
+    """
+    Time how long it takes to resolve a name using the server
+    """
+    resolver = Resolver()
+    resolver.timeout = args.timeout
+    resolver.lifetime = args.timeout
+    resolver.nameservers = [server]
+    results = []
+    while tries > 0:
+        start = time.time()
+        try:
+            result = resolver.query(name, rectype)
+        except DNSException as ex:
+            end = time.time()
+            LOG.debug("%s failed in %.2fs", server, end - start)
+            result = ex
+        else:
+            end = time.time()
+            LOG.debug("%s resolved %s %s in %.2fs", server, name, rectype, end - start)
+        results.append((end - start, result))
+        tries -= 1
+    return server, check_results(results), results
+
+
+def download_resolvers():
+    resp = requests.get('http://public-dns.info/nameservers.txt')
+    resp.raise_for_status()
+    return map(str.strip, filter(None, str(resp.text).split("\n")))
+
+
+def load_resolvers(handle):
+    return map(str.strip, filter(None, handle.read().split("\n")))
+
+
+def run(args):
+    if args.download:
+        resolvers = download_resolvers()
+    else:
+        resolvers = load_resolvers(args.resolvers)
+    random.shuffle(resolvers)
+
+    bar = progressbar.ProgressBar(redirect_stdout=True, redirect_stderr=True)
+    for resolver in bar(resolvers):
+        server, (avgtime, isgood), results = time_resolve(args, resolver, "example.com", "A")
+        if args.output and isgood:
+            args.output.write(server + "\n")
+            args.output.flush()
+        if not args.quiet:
+            color = bcolors.OKGREEN if isgood else bcolors.FAIL
+            print("%s%s (%.2fs)%s" % (color, server, avgtime, bcolors.ENDC))
+
+def main():
+    parser = argparse.ArgumentParser(description='DNS resolver list checker')
+    parser.add_argument('-o', '--output', metavar='OUTFILE',
+                        type=argparse.FileType('w+'),
+                        help="Output results to file")
+    parser.add_argument('-D', '--download', action='store_true',
+                        help='Download new list of resolvers from public-dns.info')
+    parser.add_argument('-T', '--timeout', default=0.5, type=float, metavar='SECS',
+                        help="Timeout for DNS request in seconds, default: 0.5")
+    parser.add_argument('-q', '--quiet', action='store_true',
+                        help="Don't print results to console")
+    parser.add_argument('-v', '--verbose', action='store_const',
+                        dest="loglevel", const=logging.INFO,
+                        help="Log informational messages")
+    parser.add_argument('--debug', action='store_const', dest="loglevel",
+                        const=logging.DEBUG, default=logging.WARNING,
+                        help="Log debugging messages")
+    parser.add_argument('-r', '--resolvers', metavar='RESOLVERS_FILE',
+                        default=pkg_resources.resource_stream(__name__, "resolvers.txt"),
+                        type=argparse.FileType('r'),
+                        help="Load DNS resolver servers from file")
+    args = parser.parse_args()
+    logging.basicConfig(level=args.loglevel)
+    run(args)
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,5 @@
 gevent
 pycares
+dnspython
+requests
 git+https://github.com/WoLpH/python-progressbar.git@develop