def query_dns_dumpster(cls, host): # Start DNS Dumpster session for the token request_handler = RequestHandler() dnsdumpster_session = request_handler.get_new_session() url = "https://dnsdumpster.com" if host.naked: target = host.naked else: target = host.target payload = {"targetip": target, "csrfmiddlewaretoken": None} try: dnsdumpster_session.get(url, timeout=10) jar = dnsdumpster_session.cookies for c in jar: if not c.__dict__.get("name") == "csrftoken": continue payload["csrfmiddlewaretoken"] = c.__dict__.get("value") break dnsdumpster_session.post( url, data=payload, headers={"Referer": "https://dnsdumpster.com/"}) return dnsdumpster_session.get( "https://dnsdumpster.com/static/map/{}.png".format(target)) except ConnectionError: raise RaccoonException
def generate_dns_dumpster_mapping(cls, host, sout_logger): # Start DNS Dumpster session for the token request_handler = RequestHandler() dnsdumpster_session = request_handler.get_new_session() url = "https://dnsdumpster.com" if host.naked: target = host.naked else: target = host.target payload = { "targetip": target, "csrfmiddlewaretoken": None } sout_logger.info("{} Trying to generate DNS Mapping for {} from DNS dumpster".format( COLORED_COMBOS.INFO, host)) try: dnsdumpster_session.get(url, timeout=10) jar = dnsdumpster_session.cookies for c in jar: if not c.__dict__.get("name") == "csrftoken": continue payload["csrfmiddlewaretoken"] = c.__dict__.get("value") break dnsdumpster_session.post(url, data=payload, headers={"Referer": "https://dnsdumpster.com/"}) time.sleep(3) page = dnsdumpster_session.get("https://dnsdumpster.com/static/map/{}.png".format(target)) if page.status_code == 200: path = HelpUtilities.get_output_path("{}/dns_mapping.png".format(host.target)) with open(path, "wb") as target_image: target_image.write(page.content) sout_logger.info("{} Successfully fetched DNS mapping for {}".format( COLORED_COMBOS.GOOD, host.target) ) except ConnectionError: sout_logger.info("{} Failed to generate DNS mapping. A connection error occurred.".format( COLORED_COMBOS.BAD))
def query_dns_dumpster(cls, host): # Start DNS Dumpster session for the token request_handler = RequestHandler() dnsdumpster_session = request_handler.get_new_session() url = "https://dnsdumpster.com" if host.naked: target = host.naked else: target = host.target payload = { "targetip": target, "csrfmiddlewaretoken": None } try: dnsdumpster_session.get(url, timeout=10) jar = dnsdumpster_session.cookies for c in jar: if not c.__dict__.get("name") == "csrftoken": continue payload["csrfmiddlewaretoken"] = c.__dict__.get("value") break return dnsdumpster_session.post(url, data=payload, headers={"Referer": "https://dnsdumpster.com/"}) except ConnectionError: raise RaccoonException
class URLFuzzer: def __init__(self, host, ignored_response_codes, num_threads, path_to_wordlist, follow_redirects=False): self.target = host.target self.ignored_error_codes = ignored_response_codes self.proto = host.protocol self.port = host.port self.num_threads = num_threads self.path_to_wordlist = path_to_wordlist self.wordlist = self._create_set_from_wordlist_file(path_to_wordlist) self.follow_redirects = follow_redirects self.request_handler = RequestHandler( ) # Will get the single, already initiated instance self.logger = None @staticmethod def _create_set_from_wordlist_file(wordlist): try: with open(wordlist, "r") as file: fuzzlist = file.readlines() fuzzlist = [x.replace("\n", "") for x in fuzzlist] return set(fuzzlist) except FileNotFoundError: raise FuzzerException( "Cannot open file in {}. Will not perform Fuzzing".format( wordlist)) def _log_response(self, code, url, headers): if 300 > code >= 200: color = COLOR.GREEN elif 400 > code >= 300: color = COLOR.BLUE url += " redirects to {}".format(headers.get("Location")) elif 510 > code >= 400: color = COLOR.RED else: color = COLOR.RESET self.logger.info("\t{}[{}]{} {}".format(color, code, COLOR.RESET, url)) def _build_request_url(self, uri, sub_domain): if not sub_domain: if self.port != 80 and self.port != 443: url = "{}://{}:{}/{}".format(self.proto, self.target, self.port, uri) else: url = "{}://{}/{}".format(self.proto, self.target, uri) else: if self.port != 80 and self.port != 443: url = "{}://{}.{}:{}".format(self.proto, uri, self.target, self.port) else: url = "{}://{}.{}".format(self.proto, uri, self.target) return url def _fetch(self, uri, sub_domain=False): """ Send a HEAD request to URL and print response code if it's not in ignored_error_codes :param uri: URI to fuzz :param sub_domain: If True, build destination URL with {URL}.{HOST} else {HOST}/{URL} """ url = self._build_request_url(uri, sub_domain=sub_domain) try: res = self.request_handler.send( "HEAD", url=url, allow_redirects=self.follow_redirects) if res.status_code not in self.ignored_error_codes: self._log_response(res.status_code, url, res.headers) except (AttributeError, RequestHandlerException): # res is None or another error occurred pass def get_log_file_path(self, path): if path: log_file = path else: log_file = "{}/url_fuzz.txt".format(self.target) return Logger(HelpUtilities.get_output_path(log_file)) @staticmethod def _rule_out_false_positives(response_codes, sub_domain): if any(code == 200 for code in response_codes): if sub_domain: err_msg = "Wildcard subdomain support detected (all subdomains return 200)." \ " Will not bruteforce subdomains" else: err_msg = "Web server seems to redirect requests for all resources " \ "to eventually return 200. Will not bruteforce URLs" raise FuzzerException(err_msg) def _generate_fake_requests(self, sub_domain): response_codes = [] fake_uris = (uuid.uuid4(), uuid.uuid4()) session = self.request_handler.get_new_session() for uri in fake_uris: url = self._build_request_url(uri, sub_domain) try: res = self.request_handler.send( "GET", url=url, allow_redirects=self.follow_redirects) response_codes.append(res.status_code) res = session.get(url=url, allow_redirects=self.follow_redirects) response_codes.append(res.status_code) except RequestHandlerException as e: if sub_domain: # If should-not-work.example.com doesn't resolve, no wildcard subdomain is present return [0] else: raise FuzzerException("Could not get a response from {}." " Maybe target is down ?".format( self.target)) return response_codes async def fuzz_all(self, sub_domain=False, log_file_path=None): """ Create a pool of threads and exhaust self.wordlist on self._fetch Should be run in an event loop. :param sub_domain: Indicate if this is subdomain enumeration or URL busting :param log_file_path: Log subdomain enum results to this path. """ self.logger = self.get_log_file_path(log_file_path) try: # Rule out wildcard subdomain support/all resources redirect to a 200 page response_codes = self._generate_fake_requests(sub_domain) self._rule_out_false_positives(response_codes, sub_domain) if not sub_domain: self.logger.info("{} Fuzzing URLs".format(COLORED_COMBOS.INFO)) self.logger.info("{} Reading from list: {}".format( COLORED_COMBOS.INFO, self.path_to_wordlist)) pool = ThreadPool(self.num_threads) pool.map(partial(self._fetch, sub_domain=sub_domain), self.wordlist) if not sub_domain: self.logger.info("{} Done fuzzing URLs".format( COLORED_COMBOS.INFO)) except FuzzerException as e: self.logger.info("{} {}".format(COLORED_COMBOS.BAD, e))
class WAF: def __init__(self, host): self.host = host self.cnames = host.dns_results.get('CNAME') self.request_handler = RequestHandler() self.web_server_validator = WebServerValidator() self.waf_present = False self.waf_cname_map = { "incapdns": "Incapsula", "edgekey": "Akamai", "akamai": "Akamai", "edgesuite": "Akamai", "distil": "Distil Networks", "cloudfront": "CloudFront", "netdna-cdn": "MaxCDN" } self.waf_app_method_map = { "CloudFront": WAFApplicationMethods.detect_cloudfront, "Cloudflare": WAFApplicationMethods.detect_cloudflare, "Incapsula": WAFApplicationMethods.detect_incapsula, "MaxCDN": WAFApplicationMethods.detect_maxcdn, "Edgecast": WAFApplicationMethods.detect_edgecast, "Distil Networks": WAFApplicationMethods.detect_distil, "Sucuri": WAFApplicationMethods.detect_sucuri, "Reblaze": WAFApplicationMethods.detect_reblaze } log_file = HelpUtilities.get_output_path("{}/WAF.txt".format( self.host.target)) self.logger = Logger(log_file) def _waf_detected(self, name): self.logger.info( "{} Detected WAF presence in web application: {}{}{}".format( COLORED_COMBOS.BAD, COLOR.RED, name, COLOR.RESET)) self.waf_present = True def _detect_by_cname(self): for waf in self.waf_cname_map: if any(waf in str(cname) for cname in self.cnames): self.logger.info( "{} Detected WAF presence in CNAME: {}{}{}".format( COLORED_COMBOS.BAD, COLOR.RED, self.waf_cname_map.get(waf), COLOR.RESET)) self.waf_present = True def _detect_by_application(self): try: session = self.request_handler.get_new_session() response = session.get(timeout=20, allow_redirects=True, url="{}://{}:{}".format( self.host.protocol, self.host.target, self.host.port)) for waf, method in self.waf_app_method_map.items(): result = method(response) if result: self._waf_detected(waf) except (ConnectionError, TooManyRedirects) as e: raise WAFException("Couldn't get response from server.\n" "Caused due to exception: {}".format(str(e))) async def detect(self): self.logger.info("{} Trying to detect WAF presence in {}".format( COLORED_COMBOS.INFO, self.host)) if self.cnames: self._detect_by_cname() try: self.web_server_validator.validate_target_webserver(self.host) self._detect_by_application() if not self.waf_present: self.logger.info( "{} Did not detect WAF presence in target".format( COLORED_COMBOS.GOOD)) except WebServerValidatorException: self.logger.info( "{} Target does not seem to have an active web server on port {}. " "No WAF could be detected on an application level.".format( COLORED_COMBOS.NOTIFY, self.host.port))
class WebApplicationScanner: def __init__(self, host): self.host = host self.request_handler = RequestHandler() self.web_server_validator = WebServerValidator() self.headers = None self.robots = None self.forms = None self.fuzzable_urls = set() log_file = HelpUtilities.get_output_path("{}/web_scan.txt".format( self.host.target)) self.target_dir = "/".join(log_file.split("/")[:-1]) self.logger = Logger(log_file) def _detect_cms(self, tries=0): """ Detect CMS using whatcms.org. Has a re-try mechanism because false negatives may occur :param tries: Count of tries for CMS discovery """ # WhatCMS is under CloudFlare which detects and blocks proxied/Tor traffic, hence normal request. page = requests.get( url="https://whatcms.org/?s={}".format(self.host.target)) soup = BeautifulSoup(page.text, "lxml") found = soup.select(".panel.panel-success") if found: try: cms = [a for a in soup.select("a") if "/c/" in a.get("href")][0] self.logger.info( "{} CMS detected: target is using {}{}{}".format( COLORED_COMBOS.GOOD, COLOR.GREEN, cms.get("title"), COLOR.RESET)) except IndexError: if tries >= 4: return else: self._detect_cms(tries=tries + 1) else: if tries >= 4: return else: self._detect_cms(tries=tries + 1) def _cookie_info(self, jar): for cookie in jar: key = cookie.__dict__.get("name") value = cookie.__dict__.get("value") domain = cookie.__dict__.get("domain") secure = cookie.__dict__.get("secure") http_only = cookie.has_nonstandard_attr("HttpOnly") try: if domain in self.host.target or self.host.target in domain: if not secure or not http_only: current = "%s Cookie: {%s: %s} -" % ( COLORED_COMBOS.GOOD, key, value) if not secure and not http_only: current += " both secure and HttpOnly flags are not set" elif not secure: current += " secure flag not set" else: current += " HttpOnly flag not set" self.logger.info(current) except TypeError: continue def _server_info(self): if self.headers.get("server"): self.logger.info("{} Web server detected: {}{}{}".format( COLORED_COMBOS.GOOD, COLOR.GREEN, self.headers.get("server"), COLOR.RESET)) def _x_powered_by(self): if self.headers.get("X-Powered-By"): self.logger.info("{} X-Powered-By header detected: {}{}{}".format( COLORED_COMBOS.GOOD, COLOR.GREEN, self.headers.get("X-Powered-By"), COLOR.RESET)) def _anti_clickjacking(self): if not self.headers.get("X-Frame-Options"): self.logger.info( "{} X-Frame-Options header not detected - target might be vulnerable to clickjacking" .format(COLORED_COMBOS.GOOD)) def _xss_protection(self): xss_header = self.headers.get("X-XSS-PROTECTION") if xss_header and "1" in xss_header: self.logger.info("{} Found X-XSS-PROTECTION header".format( COLORED_COMBOS.BAD)) def _cors_wildcard(self): if self.headers.get("Access-Control-Allow-Origin") == "*": self.logger.info("{} CORS wildcard detected".format( COLORED_COMBOS.GOOD)) def _robots(self): res = self.request_handler.send("GET", url="{}://{}:{}/robots.txt".format( self.host.protocol, self.host.target, self.host.port)) if res.status_code != 404 and res.text and "<!DOCTYPE html>" not in res.text: self.logger.info("{} Found robots.txt".format(COLORED_COMBOS.GOOD)) with open("{}/robots.txt".format(self.target_dir), "w") as file: file.write(res.text) def _sitemap(self): res = self.request_handler.send("GET", url="{}://{}:{}/sitemap.xml".format( self.host.protocol, self.host.target, self.host.port)) if res.status_code != 404 and res.text and "<!DOCTYPE html>" not in res.text: self.logger.info("{} Found sitemap.xml".format( COLORED_COMBOS.GOOD)) with open("{}/sitemap.xml".format(self.target_dir), "w") as file: file.write(res.text) def _find_fuzzable_urls(self, soup): urls = soup.select("a") if urls: for url in urls: href = url.get("href") if href and "?" in href and "=" in href: self.fuzzable_urls.add(href) if self.fuzzable_urls: self.logger.info("{} {} fuzzable URLs discovered".format( COLORED_COMBOS.NOTIFY, len(self.fuzzable_urls))) base_target = "{}://{}:{}".format(self.host.protocol, self.host.target, self.host.port) for url in self.fuzzable_urls: if url.startswith("/"): self.logger.debug("\t{}{}".format(base_target, url)) else: self.logger.debug("\t{}".format(url)) def _find_forms(self, soup): self.forms = soup.select("form") if self.forms: self.logger.info("{} {} HTML forms discovered".format( COLORED_COMBOS.NOTIFY, len(self.forms))) for form in self.forms: form_id = form.get("id") form_class = form.get("class") form_method = form.get("method") form_action = form.get("action") self.logger.debug( "Form details: ID: {}, Class: {}, Method: {}, action: {}". format(form_id, form_class, form_method, form_action)) def _find_emails(self, soup): pass def get_web_application_info(self): session = self.request_handler.get_new_session() try: with session: # Test if target is serving HTTP requests response = session.get(timeout=20, url="{}://{}:{}".format( self.host.protocol, self.host.target, self.host.port)) self.headers = response.headers self._detect_cms() self._robots() self._sitemap() self._server_info() self._x_powered_by() self._cors_wildcard() self._xss_protection() self._anti_clickjacking() self._cookie_info(session.cookies) soup = BeautifulSoup(response.text, "lxml") self._find_fuzzable_urls(soup) self._find_forms(soup) except (ConnectionError, TooManyRedirects) as e: raise WebAppScannerException("Couldn't get response from server.\n" "Caused due to exception: {}".format( str(e))) async def run_scan(self): self.logger.info("{} Trying to collect {} web application data".format( COLORED_COMBOS.INFO, self.host)) try: self.web_server_validator.validate_target_webserver(self.host) self.get_web_application_info() except WebServerValidatorException: self.logger.info( "{} Target does not seem to have an active web server on port: {}. " "No web application data will be gathered.".format( COLORED_COMBOS.NOTIFY, self.host.port)) return
class WAF: def __init__(self, host): self.host = host self.cnames = host.dns_results.get('CNAME') self.request_handler = RequestHandler() self.web_server_validator = WebServerValidator() self.waf_present = False self.waf_cname_map = { "incapdns": "Incapsula", "edgekey": "Akamai", "akamai": "Akamai", "edgesuite": "Akamai", "distil": "Distil Networks", "cloudfront": "CloudFront", "netdna-cdn": "MaxCDN" } self.waf_app_method_map = { "CloudFront": WAFApplicationMethods.detect_cloudfront, "Cloudflare": WAFApplicationMethods.detect_cloudflare, "Incapsula": WAFApplicationMethods.detect_incapsula, "MaxCDN": WAFApplicationMethods.detect_maxcdn, "Edgecast": WAFApplicationMethods.detect_edgecast, "Distil Networks": WAFApplicationMethods.detect_distil, "Sucuri": WAFApplicationMethods.detect_sucuri, "Reblaze": WAFApplicationMethods.detect_reblaze } log_file = HelpUtilities.get_output_path("{}/WAF.txt".format(self.host.target)) self.logger = Logger(log_file) def _waf_detected(self, name): self.logger.info( "{} Detected WAF presence in web application: {}{}{}".format( COLORED_COMBOS.BAD, COLOR.RED, name, COLOR.RESET)) self.waf_present = True def _detect_by_cname(self): for waf in self.waf_cname_map: if any(waf in str(cname) for cname in self.cnames): self.logger.info("{} Detected WAF presence in CNAME: {}{}{}".format( COLORED_COMBOS.BAD, COLOR.RED, self.waf_cname_map.get(waf), COLOR.RESET) ) self.waf_present = True def _detect_by_application(self): try: session = self.request_handler.get_new_session() response = session.get( timeout=20, allow_redirects=True, url="{}://{}:{}".format( self.host.protocol, self.host.target, self.host.port ) ) for waf, method in self.waf_app_method_map.items(): result = method(response) if result: self._waf_detected(waf) except (ConnectionError, TooManyRedirects) as e: raise WAFException("Couldn't get response from server.\n" "Caused due to exception: {}".format(str(e))) async def detect(self): self.logger.info("{} Trying to detect WAF presence in {}".format(COLORED_COMBOS.INFO, self.host)) if self.cnames: self._detect_by_cname() try: self.web_server_validator.validate_target_webserver(self.host) self._detect_by_application() if not self.waf_present: self.logger.info("{} Did not detect WAF presence in target".format(COLORED_COMBOS.GOOD)) except WebServerValidatorException: self.logger.info( "{} Target does not seem to have an active web server on port {}. " "No WAF could be detected on an application level.".format(COLORED_COMBOS.NOTIFY, self.host.port))