diff --git a/restfulHarvest.py b/restfulHarvest.py old mode 100755 new mode 100644 index b0a724c8..a62dd7bb --- a/restfulHarvest.py +++ b/restfulHarvest.py @@ -1,5 +1,4 @@ #!/usr/bin/env python3 - import uvicorn import theHarvester.lib.web.api as api import argparse @@ -7,7 +6,8 @@ parser = argparse.ArgumentParser() parser.add_argument('-H', '--host', default='127.0.0.1', help='IP address to listen on default is 127.0.0.1') parser.add_argument('-p', '--port', default=5000, help='Port to bind the web server to, default is 5000') -parser.add_argument('-l', '--log-level', default='info', help='Set logging level, default is info but [critical|error|warning|info|debug|trace] can be set') +parser.add_argument('-l', '--log-level', default='info', + help='Set logging level, default is info but [critical|error|warning|info|debug|trace] can be set') parser.add_argument('-r', '--reload', default=False, help='Enable auto-reload.', action='store_true') args = parser.parse_args() diff --git a/theHarvester/__main__.py b/theHarvester/__main__.py index 1f0b96e5..230db7a7 100644 --- a/theHarvester/__main__.py +++ b/theHarvester/__main__.py @@ -17,30 +17,50 @@ Core.banner() -async def start(): +async def start(rest_args=None): parser = argparse.ArgumentParser( description='theHarvester is used to gather open source intelligence (OSINT) on a\n' 'company or domain.') parser.add_argument('-d', '--domain', help='Company name or domain to search.', required=True) parser.add_argument('-l', '--limit', help='Limit the number of search results, default=500.', default=500, type=int) parser.add_argument('-S', '--start', help='Start with result number X, default=0.', default=0, type=int) - parser.add_argument('-g', '--google-dork', help='Use Google Dorks for Google search.', default=False, action='store_true') - parser.add_argument('-p', '--proxies', help='Use proxies for requests, enter proxies in proxies.yaml.', default=False, action='store_true') - parser.add_argument('-s', '--shodan', help='Use Shodan to query discovered hosts.', default=False, action='store_true') - parser.add_argument('-v', '--virtual-host', help='Verify host name via DNS resolution and search for virtual hosts.', action='store_const', const='basic', default=False) + parser.add_argument('-g', '--google-dork', help='Use Google Dorks for Google search.', default=False, + action='store_true') + parser.add_argument('-p', '--proxies', help='Use proxies for requests, enter proxies in proxies.yaml.', + default=False, action='store_true') + parser.add_argument('-s', '--shodan', help='Use Shodan to query discovered hosts.', default=False, + action='store_true') + parser.add_argument('-v', '--virtual-host', + help='Verify host name via DNS resolution and search for virtual hosts.', action='store_const', + const='basic', default=False) parser.add_argument('-e', '--dns-server', help='DNS server to use for lookup.') parser.add_argument('-t', '--dns-tld', help='Perform a DNS TLD expansion discovery, default False.', default=False) parser.add_argument('-r', '--take-over', help='Check for takeovers.', default=False, action='store_true') - parser.add_argument('-n', '--dns-lookup', help='Enable DNS server lookup, default False.', default=False, action='store_true') - parser.add_argument('-c', '--dns-brute', help='Perform a DNS brute force on the domain.', default=False, action='store_true') + parser.add_argument('-n', '--dns-lookup', help='Enable DNS server lookup, default False.', default=False, + action='store_true') + parser.add_argument('-c', '--dns-brute', help='Perform a DNS brute force on the domain.', default=False, + action='store_true') parser.add_argument('-f', '--filename', help='Save the results to an HTML and/or XML file.', default='', type=str) parser.add_argument('-b', '--source', help='''baidu, bing, bingapi, bufferoverun, certspotter, crtsh, dnsdumpster, dogpile, duckduckgo, exalead, github-code, google, hackertarget, hunter, intelx, linkedin, linkedin_links, netcraft, otx, pentesttools, - rapiddns, securityTrails, spyse, sublist3r, suip, threatcrowd, threatminer, - trello, twitter, urlscan, virustotal, yahoo, all''') - - args = parser.parse_args() + rapiddns, securityTrails, spyse, suip, threatcrowd, + trello, twitter, vhost, virustotal, yahoo, all''') + # determines if filename is coming from rest api or user + rest_filename = "" + # indicates this from the rest API + if rest_args: + args = rest_args + # We need to make sure the filename is random as to not overwrite other files + filename: str = args.filename + import string + import secrets + alphabet = string.ascii_letters + string.digits + rest_filename += f"{''.join(secrets.choice(alphabet) for _ in range(32))}_{filename}" if len(filename) != 0 \ + else "" + else: + args = parser.parse_args() + filename: str = args.filename try: db = stash.StashManager() await db.do_init() @@ -55,7 +75,8 @@ async def start(): dnsserver = args.dns_server dnstld = args.dns_tld engines = [] - filename: str = args.filename + # If the user specifies + full: list = [] ips: list = [] google_dorking = args.google_dork @@ -72,7 +93,7 @@ async def start(): async def store(search_engine: Any, source: str, process_param: Any = None, store_host: bool = False, store_emails: bool = False, store_ip: bool = False, store_people: bool = False, - store_data: bool = False, store_links: bool = False, store_results: bool = False) -> None: + store_links: bool = False, store_results: bool = False) -> None: """ Persist details into the database. The details to be stored is controlled by the parameters passed to the method. @@ -85,7 +106,6 @@ async def store(search_engine: Any, source: str, process_param: Any = None, stor :param store_emails: whether to store emails :param store_ip: whether to store IP address :param store_people: whether to store user details - :param store_data: whether to fetch host from method get_data() and persist :param store_links: whether to store links :param store_results: whether to fetch details from get_results() and persist """ @@ -437,6 +457,17 @@ async def handler(lst): await handler(lst=stor_lst) + return_ips = [] + print("rest_filename: ", rest_filename) + print("rest_args: ", rest_args) + if rest_args is not None and len(rest_filename) == 0: + # Indicates user is using rest api but not wanting output to be saved to a file + full = [host if ':' in host and word in host else word in host.split(':')[0] and host for host in full] + full = list({host for host in full if host}) + full.sort() + # cast to string so Rest API can understand type + return_ips.extend([str(ip) for ip in sorted([netaddr.IPAddress(ip.strip()) for ip in set(all_ip)])]) + return list(set(all_emails)), return_ips, full, "", "" # Sanity check to see if all_emails and all_hosts are defined. try: all_emails @@ -535,7 +566,7 @@ async def handler(lst): target=word, local_results=dnsrev, overall_results=full), - nameservers=[dnsserver] if dnsserver else None)) + nameservers=list(map(str, dnsserver.split(','))) if dnsserver else None)) # run all the reversing tasks concurrently await asyncio.gather(*__reverse_dns_tasks.values()) @@ -646,57 +677,81 @@ async def handler(lst): ''' - Html_file = open(f'{filename}.html' if '.html' not in filename else filename, 'w') - Html_file.write(HTMLcode) - Html_file.close() - print('[*] Reporting finished.') - print('[*] Saving files.') + if len(rest_filename) == 0: + Html_file = open(f'{filename}.html' if '.html' not in filename else filename, 'w') + Html_file.write(HTMLcode) + Html_file.close() + print('[*] Reporting finished.') + print('[*] Saving files.') + else: + # indicates the rest api is being used in that case we asynchronously write the file to our static directory + try: + import aiofiles + async with aiofiles.open( + f'theHarvester/lib/web/static/{rest_filename}.html' if '.html' not in rest_filename + else f'theHarvester/lib/web/static/{rest_filename}', 'w+') as Html_file: + await Html_file.write(HTMLcode) + except Exception as ex: + print(f"An excpetion has occurred: {ex}") + list(set(all_emails)), return_ips, full, f'{ex}', "" + # Html_file = async with aiofiles.open(f'{filename}.html' if '.html' not in filename else filename, 'w') + # Html_file.write(HTMLcode) + # Html_file.close() except Exception as e: print(e) print('\n\033[93m[!] An error occurred while creating the output file.\n\n \033[0m') sys.exit(1) try: - filename = filename.rsplit('.', 1)[0] + '.xml' - file = open(filename, 'w') - file.write('') - for x in all_emails: - file.write('' + x + '') - for x in full: - host, ip = x.split(':') if ':' in x else (x, '') - if ip and len(ip) > 3: - file.write(f'{ip}{host}') - else: - file.write(f'{host}') - for x in vhost: - host, ip = x.split(':') if ':' in x else (x, '') - if ip and len(ip) > 3: - file.write(f'{ip} {host}') - else: - file.write(f'{host}') - if shodanres != []: - shodanalysis = [] - for x in shodanres: - res = x.split('SAPO') - file.write('') - file.write('' + res[0] + '') - file.write('' + res[2] + '') - file.write('') - reg_server = re.compile('Server:.*') - temp = reg_server.findall(res[1]) - if temp: - shodanalysis.append(res[0] + ':' + temp[0]) - file.write('') - if shodanalysis: - shodanalysis = sorted(set(shodanalysis)) - file.write('') - for x in shodanalysis: - file.write('' + x + '') - file.write('') + # filename = filename.rsplit('.', 1)[0] + '.xml' + # file = open(filename, 'w') + if len(rest_filename) == 0: + filename = filename.rsplit('.', 1)[0] + '.xml' + else: + filename = 'theHarvester/lib/web/static/' \ + + rest_filename.rsplit('.', 1)[0] + '.xml' + # TODO use aiofiles if user is using rest api + with open(filename, 'w+') as file: + file.write('') + for x in all_emails: + file.write('' + x + '') + for x in full: + host, ip = x.split(':') if ':' in x else (x, '') + if ip and len(ip) > 3: + file.write(f'{ip}{host}') + else: + file.write(f'{host}') + for x in vhost: + host, ip = x.split(':') if ':' in x else (x, '') + if ip and len(ip) > 3: + file.write(f'{ip} {host}') + else: + file.write(f'{host}') + if shodanres != []: + shodanalysis = [] + for x in shodanres: + res = x.split('SAPO') + file.write('') + file.write('' + res[0] + '') + file.write('' + res[2] + '') + file.write('') + reg_server = re.compile('Server:.*') + temp = reg_server.findall(res[1]) + if temp: + shodanalysis.append(res[0] + ':' + temp[0]) + file.write('') + if shodanalysis: + shodanalysis = sorted(set(shodanalysis)) + file.write('') + for x in shodanalysis: + file.write('' + x + '') + file.write('') - file.write('') - file.flush() - file.close() + file.write('') + if len(rest_filename) > 0: + return list(set(all_emails)), return_ips, full, f'/static/{rest_filename}.html', \ + f'/static/{filename[filename.find("/static/") + 8:]}' if '/static/' in filename \ + else f'/static/{filename}' print('[*] Files saved.') except Exception as er: print(f'\033[93m[!] An error occurred while saving the XML file: {er} \033[0m') @@ -707,7 +762,6 @@ async def handler(lst): async def entry_point(): try: await start() - # await handler() except KeyboardInterrupt: print('\n\n\033[93m[!] ctrl+c detected from user, quitting.\n\n \033[0m') except Exception as error_entry_point: diff --git a/theHarvester/discovery/dnssearch.py b/theHarvester/discovery/dnssearch.py index 0db7b6e1..fdb328be 100644 --- a/theHarvester/discovery/dnssearch.py +++ b/theHarvester/discovery/dnssearch.py @@ -16,7 +16,6 @@ from typing import Callable, List, Optional from theHarvester.lib import hostchecker -# TODO: need big focus on performance and results parsing, now does the basic. ##################################################################### # DNS FORCE @@ -29,7 +28,8 @@ def __init__(self, domain, dnsserver, verbose=False): self.domain = domain self.subdo = False self.verbose = verbose - self.dnsserver = [dnsserver] if isinstance(dnsserver, str) else dnsserver + # self.dnsserver = [dnsserver] if isinstance(dnsserver, str) else dnsserver + self.dnsserver = list(map(str, dnsserver.split(','))) if isinstance(dnsserver, str) else dnsserver try: with open('wordlists/dns-names.txt', 'r') as file: self.list = file.readlines() @@ -41,9 +41,13 @@ def __init__(self, domain, dnsserver, verbose=False): async def run(self): print(f'Created checker with this many words {len(self.list)}') - checker = hostchecker.Checker(self.list) + checker = hostchecker.Checker( + self.list) if self.dnsserver == [] or self.dnsserver == "" or self.dnsserver is None \ + else hostchecker.Checker(self.list, nameserver=self.dnsserver) hosts, ips = await checker.check() return hosts, ips + + ##################################################################### # DNS REVERSE ##################################################################### @@ -159,6 +163,7 @@ async def reverse_all_ips_in_range(iprange: str, callback: Callable, nameservers callback(__host) log_result(__host) + ##################################################################### # IO ##################################################################### @@ -217,6 +222,7 @@ def generate_postprocessing_callback(target: str, **allhosts: List[str]) -> Call A function that will update the collection of target subdomains when the query result is satisfying. """ + def append_matching_hosts(host: str) -> None: if host and target in host: for __name, __hosts in allhosts.items(): diff --git a/theHarvester/lib/web/api.py b/theHarvester/lib/web/api.py index abef5ca0..6b2e97f6 100644 --- a/theHarvester/lib/web/api.py +++ b/theHarvester/lib/web/api.py @@ -1,34 +1,76 @@ -from fastapi import FastAPI +import base64 +import io from argparse import Namespace +from typing import List + +from fastapi import FastAPI, Header, Query, Request +from slowapi import Limiter, _rate_limit_exceeded_handler +from slowapi.errors import RateLimitExceeded +from slowapi.util import get_remote_address +from starlette.responses import StreamingResponse, RedirectResponse +from starlette.staticfiles import StaticFiles + from theHarvester import __main__ -app = FastAPI() + +limiter = Limiter(key_func=get_remote_address) +app = FastAPI(title="Restful Harvest", + description="Rest API for theHarvester powered by FastAPI", + version="0.0.1") +app.state.limiter = limiter +app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler) + +# This is where we will host files that arise if the user specifies a filename +# app.mount("/static", StaticFiles(directory="static/"), name="static") +app.mount("/static", StaticFiles(directory="theHarvester/lib/web/static/"), name="static") @app.get("/") -async def read_root(): - return {"Hello": "World"} +async def root(*, user_agent: str = Header(None)): + # very basic user agent filtering + if "gobuster" in user_agent or "sqlmap" in user_agent or "rustbuster" in user_agent: + response = RedirectResponse(app.url_path_for("picture")) + return response + return {'message': 'Thank you for using theHarvester rest API plea' + f'se see {app.docs_url} or {app.redoc_url} for documentation on how to use the API'} -@app.get("/test") -async def read_item(): +@app.get("/nicebot") +async def picture(): + # nice bot + string = "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" + return StreamingResponse(io.BytesIO(base64.b64decode(string))) + + +@app.get("/query") +@limiter.limit("5/minute") +async def query(request: Request, dns_server: str = Query(""), + dns_brute=Query(False), dns_lookup: bool = Query(False), + dns_tld: bool = Query(False), + filename: str = Query(""), + google_dork: bool = Query(False), proxies: bool = Query(False), shodan: bool = Query(False), + take_over: bool = Query(False), virtual_host: bool = Query(False), + source: List[str] = Query(..., description="Data sources to query comma separated with no space"), + limit: int = Query(500), start: int = Query(0), domain: str = Query(..., description="Domain to be " + "harvested")): + # Query function that allows user to query theHarvester rest API + # Rate limit of 5 requests per minute try: - emails, ips, urls = await __main__.start( - Namespace(dns_brute=False, - dns_lookup=False, - dns_server=None, - dns_tld=False, - domain='yale.edu', - filename='', - google_dork=False, - limit='', - proxies=False, - shodan=False, - source='bing,intelx', - start=0, - take_over=False, - virtual_host=False)) - return {'emails': emails, 'ips': ips, 'urls': urls} + emails, ips, urls, html_filename, xml_filename = await __main__.start(Namespace(dns_brute=dns_brute, + dns_lookup=dns_lookup, + dns_server=dns_server, + dns_tld=dns_tld, + domain=domain, + filename=filename, + google_dork=google_dork, + limit=limit, + proxies=proxies, + shodan=shodan, + source=','.join(source), + start=start, + take_over=take_over, + virtual_host=virtual_host)) + + return {'domain': f'{domain}', 'emails': emails, 'ips': ips, 'urls': urls, 'html_file': f'{html_filename}', + 'xml_file': f'{xml_filename}'} except Exception as e: return {'exception': f'{e}'} -if __name__ == '__main__': - print(__name__) diff --git a/theHarvester/lib/web/parser.py b/theHarvester/lib/web/parser.py new file mode 100644 index 00000000..96692bf5 --- /dev/null +++ b/theHarvester/lib/web/parser.py @@ -0,0 +1,60 @@ +""" +Example script to query theHarvester rest API, obtain results, and write out to stdout as well as an html & xml file +""" + +import asyncio +import pprint + +import aiohttp + + +async def fetch_json(session, url): + async with session.get(url) as response: + return await response.json() + + +async def fetch(session, url): + async with session.get(url) as response: + return await response.text() + + +async def main(): + """ + Just a simple example of how to interact with the rest api + you can easily use requests instead of aiohttp or whatever you best see fit + """ + url = "http://127.0.0.1:5000" + domain = "netflix.com" + query_url = f'{url}/query?limit=300&filename=helloworld&source=bing,baidu,duckduckgo,dogpile&domain={domain}' + async with aiohttp.ClientSession() as session: + fetched_json = await fetch_json(session, query_url) + emails = fetched_json["emails"] + ips = fetched_json["ips"] + urls = fetched_json["urls"] + html_filename = fetched_json["html_file"] + xml_filename = fetched_json["xml_file"] + + async with aiohttp.ClientSession() as session: + html_file = await fetch(session, f"{url}{html_filename}") + xml_file = await fetch(session, f"{url}{xml_filename}") + + if len(html_file) > 0: + with open('results.html', 'w+') as fp: + fp.write(html_file) + + if len(xml_file) > 0: + with open('results.xml', 'w+') as fp: + fp.write(xml_file) + + print('Emails found: ') + pprint.pprint(emails, indent=4) + print('\n') + print('Ips found: ') + pprint.pprint(ips, indent=4) + print('\n') + print('Urls found: ') + pprint.pprint(urls, indent=4) + + +if __name__ == '__main__': + asyncio.run(main()) diff --git a/theHarvester/lib/web/requirements.txt b/theHarvester/lib/web/requirements.txt new file mode 100644 index 00000000..ee4ceca3 --- /dev/null +++ b/theHarvester/lib/web/requirements.txt @@ -0,0 +1,6 @@ +aiofiles +argparse +fastapi==0.54.1 +slowapi +uvicorn +uvloop diff --git a/theHarvester/lib/web/static/test.txt b/theHarvester/lib/web/static/test.txt new file mode 100644 index 00000000..95d09f2b --- /dev/null +++ b/theHarvester/lib/web/static/test.txt @@ -0,0 +1 @@ +hello world \ No newline at end of file