diff --git a/Readme.md b/Readme.md index b096be9..ff0dc62 100644 --- a/Readme.md +++ b/Readme.md @@ -1,6 +1,6 @@ # pdfgrab -* Version 0.4.8-Pre +* Version 0.4.9 ## What is it? @@ -9,21 +9,18 @@ Basically it analyses PDF files for Metadata. You can direct it to a file or dir You can show it the url of a pdf or use the integrated googlesearch (thanx to mario vilas class) to search for pdfs at target site, download and analyse them. -## What is new in 0.4.8 bug fix pre-release? +## What is new in 0.4.9? -* catching google error at too many requests -* catching dns resolve urlopen error at googlelib -* fixing annoying bug in regard of pdfs behind urls like http://host/pdf/ -* fixing zero size pdf error(online linked pdfs which are not accessable) -* added some logging - -## What is new in 0.4.7 release? - -* Added support for html output file, this will be placed in the outdir path and is more clear then a text or json file -* Added basic logging support, logfile is placed in pdfgrab.py directory -* Reordered Codebase, exported functionality to some libraries -* PDF XMP Metadata is grabbed now as well, but not yet saved in output files -* added docs/ section with Changelog and Todo +* exported reporting methods to libreport.py +* added optargs for disabling different report methods +* made the html report a bit more shiny +* added function for generating html report after analysis +* exported requests and storing data to new library +* code fixes and more clear error handling +* removed necessary site: parameter at search flag -s +* updated readme +* -s flag now acceppts several domains +* console logging more clean ## What information can be gathered? @@ -132,7 +129,7 @@ Will analyse all pdf's in that directory ### Google Search Mode ``` -# ./pdfgrab.py -s site:kernel.org +# ./pdfgrab.py -s kernel.org ``` Result: ``` @@ -164,6 +161,26 @@ File: pdfgrab/bpf_global_data_and_static_keys.pdf /PTEX.Fullbanner This is pdfTeX, Version 3.14159265-2.6-1.40.17 (TeX Live 2016) kpathsea version 6.2.2 ``` +### Google Search Mode, several domains +``` +# ./pdfgrab.py -s example.com,example.us +``` + +### Reporting + +pdfgrab outputs the information in different formats. If not disabled by one of the reporting flags (see -h) you will +find in the output directory: + +* html report +* text report +* text url list +* json data +* json url list + +### Logging + +pdfgrab creates a logfile in the running directory called "pdfgrab.log" + ## Google * Search: filetype:pdf site:com diff --git a/docs/Changelog b/docs/Changelog index e85582b..45488af 100644 --- a/docs/Changelog +++ b/docs/Changelog @@ -1,6 +1,20 @@ Changelog ========= +Version 4.9 +----------- + +* exported reporting methods to libreport.py +* added optargs for disabling different report methods +* made the html report a bit more shiny +* added function for generating html report after analysis +* exported requests and storing data to new library +* code fixes and more clear error handling +* removed necessary site: parameter at search flag -s +* updated readme +* -s flag now acceppts several domains +* console logging more clean + Version 4.8 Bugfix-PreRelease ----------------------------- diff --git a/libs/libgoogle.py b/libs/libgoogle.py index e658c63..4d23847 100644 --- a/libs/libgoogle.py +++ b/libs/libgoogle.py @@ -5,19 +5,44 @@ from libs.libhelper import * def get_random_agent(): return (gs.get_random_user_agent()) -def search_pdf(search, args): +def hits_google(search, args): + ''' the function where googlesearch from mario vilas + is called + ''' + s = search.split(',') + query = 'filetype:pdf' + + + try: + hits = gs.hits(query, domains=s,user_agent=gs.get_random_user_agent()) + + except urllib.error.HTTPError as e: + return False,e + + except urllib.error.URLError as e: + return False,e + + except IndexError as e: + return False,e + + return True,hits + + +def search_google(search, args): ''' the function where googlesearch from mario vilas is called ''' + s = search.split(',') search_stop = args.search_stop - query = '%s filetype:pdf' % search + query = 'filetype:pdf' + #query = 'site:%s filetype:pdf' % search # print(query) urls = [] try: - for url in gs.search(query, num=20, stop=search_stop, user_agent=gs.get_random_user_agent()): + for url in gs.search(query, num=20, domains=s,stop=search_stop, user_agent=gs.get_random_user_agent()): #print(url) urls.append(url) diff --git a/libs/liblog.py b/libs/liblog.py index 2c01d25..66d19cd 100644 --- a/libs/liblog.py +++ b/libs/liblog.py @@ -8,10 +8,12 @@ file_handler = logging.FileHandler('pdfgrab.log') console_handler = logging.StreamHandler() console_handler.setLevel(logging.WARNING) -formatter = logging.Formatter('%(asctime)s:%(name)s:%(levelname)s:%(message)s') +file_formatter = logging.Formatter('%(asctime)s:%(name)s:%(levelname)s:%(message)s') +console_formatter = logging.Formatter('%(levelname)s:%(message)s') -file_handler.setFormatter(formatter) -console_handler.setFormatter(formatter) + +file_handler.setFormatter(file_formatter) +console_handler.setFormatter(console_formatter) logger.addHandler(file_handler) logger.addHandler(console_handler) diff --git a/libs/libreport.py b/libs/libreport.py new file mode 100644 index 0000000..3bb5679 --- /dev/null +++ b/libs/libreport.py @@ -0,0 +1,173 @@ +import os +import sys +import json +from json2html import * +from libs.pdf_png import get_png_base64 + +def prepare_analysis_dict(ana_queue): + '''params: ana_queue - queue with collected information + ''' + # initiate analysis dictionary + analysis_dict = {} + + # move analysis dictionary in queue back to dictionary + while ana_queue.empty() == False: + item = ana_queue.get() + # print('item ', item) + analysis_dict.update(item) + + # ana_q is empty now return the newly created dictionary + return analysis_dict + +def create_txt_report(analysis_dict, outdir, out_filename): + ''' create a txt report in the output directory + ''' + + # draw seperator lines + sep = '-' * 80 + '\n' + + # create output filepath + txtout = "%s/%s.txt" % (outdir, out_filename) + + # open the file and return filedescriptor + fwtxt = open(txtout, 'w') + + # get the keys of the dict + for k in analysis_dict.keys(): + # write seperator + fwtxt.write(sep) + + # build entry filename of the pdf + fname = 'File: %s\n' % (analysis_dict[k]['filename']) + + # build data entry + ddata = analysis_dict[k]['data'] + + # write the filename + fwtxt.write(fname) + + # write the metadata + for kdata in ddata.keys(): + metatxt = '%s:%s\n' % (kdata, ddata[kdata]) + fwtxt.write(metatxt) + + # write seperator + fwtxt.write(sep) + + # close the file + fwtxt.close() + + return True + +def create_json_report(analysis_dict, outdir, out_filename): + ''' create a jsonfile report in the output directory + ''' + + # build json output name + jsonout = "%s/%s.json" % (outdir, out_filename) + + # open up json output file + fwjson = open(jsonout, 'w') + + # convert dictionary to json data + jdata = json.dumps(analysis_dict) + + # write json data to file + fwjson.write(jdata) + + # close file + fwjson.close() + + return True + +def create_html_report(analysis_dict, outdir, out_filename): + ''' create a html report from json file using json2html in the output directory + ''' + + # build up path for html output file + htmlout = "%s/%s.html" % (outdir, out_filename) + + # open htmlout filedescriptor + fwhtml = open(htmlout,'w') + + # some html stuff + pdfpng=get_png_base64('supply/pdf_base64.png') + html_style ='\n' + html_head = 'pdfgrab - {0} item/s{1}\n'.format(len(analysis_dict),html_style) + html_pdf_png = '


pdfgrab - grab and analyse pdf files

'.format(pdfpng) + html_body = '{0}\n'.format(html_pdf_png) + html_end = '\n

pdfgrab by dash

\n' + + # some attributes + attr = 'id="meta-data" class="table table-bordered table-hover", border=1, cellpadding=3 summary="Metadata"' + + # convert dictionary to json data + # in this mode each finding gets its own table there are other possibilities + # but now i go with this + html_out = '' + for k in analysis_dict.keys(): + trans = analysis_dict[k] + jdata = json.dumps(trans) + html = json2html.convert(json = jdata, table_attributes=attr) + html_out = html_out + html + "\n" + #html_out = html_out + "

" + html + "

\n" + #jdata = json.dumps(analysis_dict) + + # create html + #html = json2html.convert(json = jdata, table_attributes=attr) + + # write html + fwhtml.write(html_head) + fwhtml.write(html_body) + fwhtml.write(html_out) + fwhtml.write(html_end) + + # close html file + fwhtml.close() + +def create_url_json(url_d, outdir, out_filename): + ''' create a json url file in output directory + ''' + + # create url savefile + jsonurlout = "%s/%s_url.json" % (outdir, out_filename) + + # open up file for writting urls down + fwjson = open(jsonurlout, 'w') + + # convert url dictionary to json + jdata = json.dumps(url_d) + + # write json data to file + fwjson.write(jdata) + + # close filedescriptor + fwjson.close() + + return True + +def create_url_txt(url_d, outdir, out_filename): + ''' create a txt url file in output directory + ''' + # build up txt out path + txtout = "%s/%s_url.txt" % (outdir, out_filename) + + # open up our url txtfile + fwtxt = open(txtout, 'w') + + # iterating through the keys of the url dictionary + for k in url_d.keys(): + + # get the entry + ddata = url_d[k] + + # create meta data for saving + metatxt = '%s:%s\n' % (ddata['url'], ddata['filename']) + + # write metadata to file + fwtxt.write(metatxt) + + # close fd + fwtxt.close() + + return True diff --git a/libs/librequest.py b/libs/librequest.py new file mode 100644 index 0000000..a8df76b --- /dev/null +++ b/libs/librequest.py @@ -0,0 +1,162 @@ +import os +import sys +import json +import socket +import requests + +from libs.liblog import logger +from libs.libhelper import * +from libs.libgoogle import get_random_agent + +def store_file(url, data, outdir): + ''' storing the downloaded data to a file + params: url - is used to create the filename + data - the data of the file + outdir - to store in which directory + returns: dict { "code":, "data":,"error":} - the status code, the savepath, the errorcode + ''' + + logger.info('Store file {0}'.format(url)) + name = find_name(url) + + # only allow stored file a name with 50 chars + if len(name) > 50: + name = name[:49] + + # build up the save path + save = "%s/%s" % (outdir, name) + + try: + f = open(save, "wb") + + except OSError as e: + logger.warning('store_file {0}'.format(e)) + # return ret_dict + return {"code":False,"data":save,"error":e} + + # write the data and return the written bytes + ret = f.write(data) + + # check if bytes are zero + if ret == 0: + logger.warning('Written {0} bytes for file: {1}'.format(ret,save)) + + else: + # log to info that bytes and file has been written + logger.info('Written {0} bytes for file: {1}'.format(ret,save)) + + # close file descriptor + f.close() + + # return ret_dict + return {"code":True,"data":save,"error":False} + + +def download_file(url, args, header_data): + ''' downloading the file for later analysis + params: url - the url + args - argparse args namespace + header_data - pre-defined header data + returns: ret_dict + ''' + + # check the remote tls certificate or not? + cert_check = args.cert_check + + # run our try catch routine + try: + # request the url and save the response in req + # give header data and set verify as delivered by args.cert_check + req = requests.get(url, headers=header_data, verify=cert_check) + + except requests.exceptions.SSLError as e: + logger.warning('download file {0}{1}'.format(url,e)) + + # return retdict + return {"code":False,"data":req,"error":e} + + except requests.exceptions.InvalidSchema as e: + logger.warning('download file {0}{1}'.format(url,e)) + + # return retdict + return {"code":False,"data":False,"error":e} + + except socket.gaierror as e: + logger.warning('download file, host not known {0} {1}'.format(url,e)) + return {"code":False,"data":False,"error":e} + + except: + logger.warning('download file, something wrong with remote server? {0}'.format(url)) + # return retdict + if not req in locals(): + req = False + + return {"code":False,"data":req,"error":True} + + #finally: + # lets close the socket + #req.close() + + # return retdict + return {"code":True,"data":req,"error":False} + +def grab_run(url, args, outdir): + ''' function keeping all the steps for the user call of grabbing + just one and analysing it + ''' + header_data = {'User-Agent': get_random_agent()} + rd_download = download_file(url, args, header_data) + code_down = rd_download['code'] + + # is code True download of file was successfull + if code_down: + rd_evaluate = evaluate_response(rd_download) + code_eval = rd_evaluate['code'] + # if code is True, evaluation was also successful + if code_eval: + # get the content from the evaluate dictionary request + content = rd_evaluate['data'].content + + # call store file + rd_store = store_file(url, content, outdir) + + # get the code + code_store = rd_store['code'] + + # get the savepath + savepath = rd_store['data'] + + # if code is True, storing of file was also successfull + if code_store: + return {"code":True,"data":savepath,"error":False} + + return {"code":False,"data":False,"error":True} + +def evalute_content(ret_dict): + pass + +def evaluate_response(ret_dict): + ''' this method comes usually after download_file, + it will evaluate what has happened and if we even have some data to process + or not + params: data - is the req object from the conducted request + return: {} + returns: dict { "code":, "data":,"error":} - the status code, the savepath, the errorcode + ''' + # extract data from ret_dict + req = ret_dict['data'] + + # get status code + url = req.url + status = req.status_code + reason = req.reason + + # ahh everything is fine + if status == 200: + logger.info('download file, {0} {1} {2}'.format(url,reason,status)) + return {"code":True,"data":req,"error":False} + + # nah something is not like it should be + else: + logger.warning('download file, {0} {1} {2}'.format(url,reason,status)) + return {"code":False,"data":req,"error":True} diff --git a/libs/pdf_png.py b/libs/pdf_png.py new file mode 100644 index 0000000..9ec8052 --- /dev/null +++ b/libs/pdf_png.py @@ -0,0 +1,5 @@ + +def get_png_base64(filename): + fr = open(filename,'r') + buf = fr.read() + return buf diff --git a/pdfgrab.py b/pdfgrab.py index cb5ed69..d620653 100755 --- a/pdfgrab.py +++ b/pdfgrab.py @@ -22,12 +22,14 @@ from PyPDF2 import pdf from libs.liblog import logger from libs.libhelper import * from libs.libgoogle import * +from libs.libreport import * +from libs.librequest import grab_run from IPython import embed # some variables in regard of the tool itself name = 'pdfgrab' -version = '0.4.8-Pre' +version = '0.4.9' author = 'dash' date = 'November 2019' @@ -243,72 +245,6 @@ def check_encryption(filename): return True - -def download_pdf(url, args, header_data): - ''' downloading the pdfile for later analysis ''' - - # check the remote tls certificate or not? - cert_check = args.cert_check - - try: - req = requests.get(url, headers=header_data, verify=cert_check) - # req = requests.get(url,headers=header_data,verify=False) - data = req.content - status_code = req.status_code - - except requests.exceptions.SSLError as e: - logger.warning('download pdf {0}{1}'.format(url,e)) - return -1 - - except: - logger.warning('download pdf, something wrong with remote server? {0}'.format(url)) - return -1 - - if status_code == 403: - logger.warning('download pdf, 403 Forbidden {0}'.format(url)) - return -1 - - # print(len(data)) - return data - - -def store_pdf(url, data, outdir): - ''' storing the downloaded pdf data - ''' - - logger.info('Store pdf {0}'.format(url)) - name = find_name(url) - #logger.warning(url) - #logger.warning(name) - #logger.warning(outdir) - - # only allow stored file a name with 50 chars - if len(name) > 50: - name = name[:49] + '.pdf' - # print(len(name)) - - save = "%s/%s" % (outdir, name) - - try: - f = open(save, "wb") - except OSError as e: - logger.warning('store_pdf {0}'.format(e)) - return -1 - - ret = f.write(data) - logger.info('Written {0} bytes for file: {1}'.format(ret,save)) - f.close() - - if ret == 0: - logger.warning('Written {0} bytes for file: {1}'.format(ret,save)) - return save - #return -1 - - - # return the savepath - return save - - def _parse_pdf(filename): ''' the real parsing function ''' @@ -320,26 +256,18 @@ def _parse_pdf(filename): logger.warning('Filesize is 0 bytes at file: {0}'.format(filename)) return False - -def grab_url(url, args, outdir): - ''' function keeping all the steps for the user call of grabbing - just one pdf and analysing it - ''' - header_data = {'User-Agent': get_random_agent()} - data = download_pdf(url, args, header_data) - if data != -1: - savepath = store_pdf(url, data, outdir) - _parse_pdf(savepath) - - return - - def seek_and_analyse(search, args, outdir): ''' function for keeping all the steps of searching for pdfs and analysing them together ''' + # check how many hits we got + # seems like the method is broken in googlsearch library :( + #code, hits = hits_google(search,args) + #if code: + # print('Got {0} hits'.format(hits)) + # use the search function of googlesearch to get the results - code, values=search_pdf(search, args) + code, values=search_google(search, args) if not code: if values.code == 429: logger.warning('[-] Too many requests, time to change ip address or use proxychains') @@ -362,7 +290,11 @@ def seek_and_analyse(search, args, outdir): item = url_q.get() # print(item) url = item['url'] - grab_url(url, args, outdir) + rd_grabrun = grab_run(url, args, outdir) + code = rd_grabrun['code'] + savepath = rd_grabrun['data'] + if code: + _parse_pdf(savepath) return True @@ -372,6 +304,9 @@ def run(args): # initialize logger logger.info('{0} Started'.format(name)) + # create some variables + + # outfile name if args.outfile: out_filename = args.outfile @@ -381,6 +316,7 @@ def run(args): # specify output directory outdir = args.outdir + # create output directory make_directory(outdir) @@ -417,68 +353,43 @@ def run(args): fpath = '%s/%s' % (directory, f) _parse_pdf(fpath) + # simply generate html report from json outfile + elif args.gen_html_report: + fr = open(args.gen_html_report,'r') + analysis_dict = json.loads(fr.read()) + if create_html_report(analysis_dict, outdir,out_filename): + logger.info('Successfully created html report') + sys.exit(0) + else: + sys.exit(1) + else: print('[-] Dunno what to do, bro. Use help. {0} -h'.format(sys.argv[0])) + sys.exit(1) - # move analysis dictionary in queue back to dictionary - analysis_dict = {} - while ana_q.empty() == False: - item = ana_q.get() - # print('item ', item) - analysis_dict.update(item) + # creating the analysis dictionary for reporting + analysis_dict = prepare_analysis_dict(ana_q) - #print('dict:',analysis_dict) - # ana_q is empty now + # lets go through the different reporting types + if args.report_txt: + if create_txt_report(analysis_dict, outdir,out_filename): + logger.info('Successfully created txt report') - # create txt output - sep = '-' * 80 + '\n' - txtout = "%s/%s.txt" % (outdir, out_filename) - fwtxt = open(txtout, 'w') - # print(analysis_dict) - for k in analysis_dict.keys(): - fwtxt.write(sep) - fname = 'File: %s\n' % (analysis_dict[k]['filename']) - ddata = analysis_dict[k]['data'] - fwtxt.write(fname) - for kdata in ddata.keys(): - metatxt = '%s:%s\n' % (kdata, ddata[kdata]) - fwtxt.write(metatxt) - fwtxt.write(sep) - fwtxt.close() + if args.report_json: + if create_json_report(analysis_dict, outdir,out_filename): + logger.info('Successfully created json report') - # create json output - jsonout = "%s/%s.json" % (outdir, out_filename) - fwjson = open(jsonout, 'w') + if args.report_html: + if create_html_report(analysis_dict, outdir,out_filename): + logger.info('Successfully created html report') - # print(analysis_dict) - jdata = json.dumps(analysis_dict) - fwjson.write(jdata) - fwjson.close() + if args.report_url_txt: + if create_url_txt(url_d, outdir,out_filename): + logger.info('Successfully created txt url report') - # create html from json - htmlout = "%s/%s.html" % (outdir, out_filename) - fwhtml = open(htmlout,'w') - #print(jdata) - html = json2html.convert(json = jdata) - fwhtml.write(html) - fwhtml.close() - - - # create url savefile - # print('url_d: ', url_d) - jsonurlout = "%s/%s_url.json" % (outdir, out_filename) - fwjson = open(jsonurlout, 'w') - jdata = json.dumps(url_d) - fwjson.write(jdata) - fwjson.close() - - txtout = "%s/%s_url.txt" % (outdir, out_filename) - fwtxt = open(txtout, 'w') - for k in url_d.keys(): - ddata = url_d[k] - metatxt = '%s:%s\n' % (ddata['url'], ddata['filename']) - fwtxt.write(metatxt) - fwtxt.close() + if args.report_url_json: + if create_url_json(url_d, outdir,out_filename): + logger.info('Successfully created json url report') return 42 @@ -504,8 +415,14 @@ def main(): help="specify domain or tld to scrape for pdf-files", default=None) parser.add_argument('-sn', '--search-number', action='store', dest='search_stop', required=False, help="specify how many files are searched", default=10, type=int) - parser.add_argument('-z', '--disable-cert-check', action='store_false', dest='cert_check', required=False, - help="if the target domain(s) run with old or bad certificates", default=True) + parser.add_argument('-z', '--disable-cert-check', action='store_false', dest='cert_check', required=False,help="if the target domain(s) run with old or bad certificates", default=True) + + parser.add_argument('-ghr', '--gen-html-report', action='store', dest='gen_html_report', required=False,help="If you want to generate the html report after editing the json outfile (parameter: pdfgrab_analysis.json)") + parser.add_argument('-rtd', '--report-text-disable', action='store_false', dest='report_txt', required=False,help="Disable txt report",default=True) + parser.add_argument('-rjd', '--report-json-disable', action='store_false', dest='report_json', required=False,help="Disable json report",default=True) + parser.add_argument('-rhd', '--report-html-disable', action='store_false', dest='report_html', required=False,help="Disable html report",default=True) + parser.add_argument('-rutd', '--report-url-text-disable', action='store_false', dest='report_url_txt', required=False,help="Disable url txt report",default=True) + parser.add_argument('-rujd', '--report-url-json-disable', action='store_false', dest='report_url_json', required=False,help="Disable url json report",default=True) if len(sys.argv)<2: parser.print_help(sys.stderr) diff --git a/supply/pdf.png b/supply/pdf.png new file mode 100644 index 0000000..769b407 Binary files /dev/null and b/supply/pdf.png differ diff --git a/supply/pdf_base64.png b/supply/pdf_base64.png new file mode 100644 index 0000000..f7f3a2e --- /dev/null +++ b/supply/pdf_base64.png @@ -0,0 +1 @@ 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 \ No newline at end of file