This Repository is a collection of different ethical hacking tools and malware's for penetration testing and research purpose written in python, ruby, rust, c++, go and c.
JavaScript algorithmsartificial-intelligencebugbountycryptographycyber-threat-intelligencecybersecurity-projectsethical-hackinghacking-toolsmalwarenessusnetwork-monitoringnetwork-securitynmapportscannerpythonpythonprojectsthreat-intelligencevirus-scanning
Create Nessus REST interface.py
Abdul Wahab Junaid9a015fd0715a
diff --git a/Nessus Attack Scripting Language/Images/Nessus REST interface.py b/Nessus Attack Scripting Language/Images/Nessus REST interface.pynew file mode 100644index 0000000..ea65115--- /dev/null+++ b/Nessus Attack Scripting Language/Images/Nessus REST interface.py@@ -0,0 +1,1145 @@+# Copyright (c) 2014-2015, Tenable Network Security, Inc.+# All rights reserved.+#+# Redistribution and use in source and binary forms, with or without+# modification, are permitted provided that the following conditions are met:+# - Redistributions of source code must retain the above copyright notice,+# this list of conditions and the following disclaimer.+# - Redistributions in binary form must reproduce the above copyright notice,+# this list of conditions and the following disclaimer in the documentation+# and/or other materials provided with the distribution.+# - Neither the name of Tenable Network Security, Inc. nor the names of its+# contributors may be used to endorse or promote products derived from this+# software without specific prior written permission.+#+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS IS" AND+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, TITLE,+# NON-INFRINGEMENT, INTEGRATION, PERFORMANCE, AND ACCURACY AND ANY IMPLIED+# WARRANTIES ARISING FROM STATUTE, COURSE OF DEALING, COURSE OF PERFORMANCE, OR+# USAGE OF TRADE, ARE DISCLAIMED. IN NO EVENT SHALL TENABLE NETWORK SECURITY,+# INC., OR ANY SUCCESSOR-IN-INTEREST, BE LIABLE FOR ANY DIRECT, INDIRECT,+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,+# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.++from __future__ import print_function+'''+Module for interacting with Nessus REST interface+'''++import os+import sys+import atexit+import time+import requests+import json+import collections+++class SSLException(Exception):+ pass+++class Scanner(object):+ '''+ Scanner object+ '''+ def __init__(self, url, login='', password='', api_akey='', api_skey='',+ insecure=False, ca_bundle='', auto_logout=True):+ self.api_akey = None+ self.api_skey = None+ self.use_api = False+ self.name = ''+ self.policy_name = ''+ self.debug = False+ self.format = ''+ self.format_start = ''+ self.format_end = ''+ self.http_response = ''+ self.plugins = {}+ self.names = {}+ self.files = {}+ self.cisco_offline_configs = ''+ self.permissions = ''+ self.policy_id = ''+ self.policy_object = ''+ self.pref_cgi = ''+ self.pref_paranoid = ''+ self.pref_supplied = ''+ self.pref_thorough = ''+ self.pref_max_checks = ''+ self.pref_receive_timeout = ''+ self.set_safe_checks = ''+ self.pref_verbose = ''+ self.pref_silent_dependencies = ''+ self.res = {}+ self.scan_id = ''+ self.scan_name = ''+ self.scan_template_uuid = ''+ self.scan_uuid = ''+ self.tag_id = ''+ self.tag_name = ''+ self.targets = ''+ self.policy_template_uuid = ''+ self.token = ''+ self.url = url+ self.ver_feed = ''+ self.ver_gui = ''+ self.ver_plugins = ''+ self.ver_svr = ''+ self.ver_web = ''+ self.ca_bundle = ca_bundle+ self.insecure = insecure+ self.auth = []+ self.host_vulns = {}+ self.plugin_output = {}+ self.host_details = {}+ self.host_ids = {}++ if insecure and hasattr(requests, 'packages'):+ requests.packages.urllib3.disable_warnings()++ if (api_akey and api_skey):+ self.api_akey = api_akey+ self.api_skey = api_skey+ self.use_api = True+ else:+ # Initial login to get our token for all subsequent transactions+ self._login(login, password)++ # Register a call to the logout action automatically+ if auto_logout:+ atexit.register(self.action, action="session",+ method="delete", retry=False)++ self._get_permissions()+ self._get_scanner_id()++################################################################################+ def _login(self, login="", password=""):+ if login and password:+ self.auth = [login,password]++ self.action(action="session",+ method="POST",+ extra={"username": self.auth[0], "password": self.auth[1]},+ private=True,+ retry=False)++ try:+ self.token = self.res["token"]++ except KeyError:+ if self.res["error"]:+ print("It looks like you're trying to login into a Nessus 5")+ print("instance. Exiting.")+ sys.exit(0)++################################################################################+ def logout(self):+ self.action(action="session", method="delete", retry=False)++################################################################################+ def _get_permissions(self):+ '''+ All development has been conducted using and administrator account which+ had the permissions '128'+ '''+ self.action(action="session", method="GET")+ self.permissions = self.res['permissions']++################################################################################+ def _get_scanner_id(self):+ '''+ Pull in information about scanner. The ID is necessary, everything else+ is "nice to have" for debugging.+ '''+ self.action(action="scanners", method="GET")++ try:+ for scanner in self.res["scanners"]:+ if scanner["type"] == "local":+ self.scanner_id = scanner['id']+ self.ver_plugins = scanner['loaded_plugin_set']+ self.ver_gui = scanner['ui_version']+ self.ver_svr = scanner['engine_version']+ self.ver_feed = scanner['license']['type']+ except:+ pass++################################################################################+ def action(self, action, method, extra={}, files={}, json_req=True, download=False, private=False, retry=True):+ '''+ Generic actions for REST interface. The json_req may be unneeded, but+ the plugin searching functionality does not use a JSON-esque request.+ This is a backup setting to be able to change content types on the fly.+ '''+ payload = {}+ payload.update(extra)+ if self.use_api:+ headers = {'X-ApiKeys': 'accessKey=' + self.api_akey ++ '; secretKey=' + self.api_skey}+ else:+ headers = {'X-Cookie': 'token=' + str(self.token)}++ if json_req:+ headers.update({'Content-type': 'application/json',+ 'Accept': 'text/plain'})+ payload = json.dumps(payload)++ url = "%s/%s" % (self.url, action)+ if self.debug:+ if private:+ print("JSON : **JSON request hidden**")+ else:+ print("JSON :")+ print(payload)++ print("HEADERS :")+ print(headers)+ print("URL : %s " % url)+ print("METHOD : %s" % method)+ print("\n")++ # Figure out if we should verify SSL connection (possibly with a user+ # supplied CA bundle). Default to true.+ if self.insecure:+ verify = False+ elif self.ca_bundle:+ verify = self.ca_bundle+ else:+ verify = True++ try:+ req = requests.request(method, url, data=payload, files=files,+ verify=verify, headers=headers)++ if not download and req.text:+ self.res = req.json()+ elif not req.text:+ self.res = {}++ if req.status_code != 200:+ print("*****************START ERROR*****************")+ if private:+ print("JSON : **JSON request hidden**")+ else:+ print("JSON :")+ print(payload)+ print(files)++ print("HEADERS :")+ print(headers)+ print("URL : %s " % url)+ print("METHOD : %s" % method)+ print("RESPONSE: %d" % req.status_code)+ print("\n")+ self.pretty_print()+ print("******************END ERROR******************")++ if self.debug:+ # This could also contain "pretty_print()" but it makes a lot of+ # noise if enabled for the entire scan.+ print("RESPONSE CODE: %d" % req.status_code)++ if download:+ return req.content+ except requests.exceptions.SSLError as ssl_error:+ raise SSLException('%s for %s.' % (ssl_error, url))+ except requests.exceptions.ConnectionError:+ raise Exception("Could not connect to %s.\nExiting!\n" % url)++ if self.res and "error" in self.res and retry:+ if self.res["error"] == "You need to log in to perform this request" or self.res["error"] == "Invalid Credentials":+ self._login()+ self.action(action=action, method=method, extra=extra, files=files,+ json_req=json_req, download=download, private=private,+ retry=False)++################################################################################+ def _policy_template_uuid(self, name):+ '''+ Get the template ID. This provides the default settings for the policy.+ '''+ self.action(action="editor/policy/templates", method="GET")+ for template in self.res["templates"]:+ if template["name"] == name:+ self.policy_template_uuid = template["uuid"]+ break++################################################################################+ def _scan_template_uuid(self, name):+ '''+ Get the template ID. This provides the default settings for the policy.+ '''+ self.action(action="editor/scan/templates", method="GET")+ for template in self.res["templates"]:+ if template["name"] == name:+ self.scan_template_uuid = template["uuid"]+ break++################################################################################+ def policy_add(self, name, plugins=None, credentials=[], template="advanced"):+ '''+ Add a policy and store the returned ID. The template defaults to+ "advanced" to remain compatible with the calls that occur in Nessus+ 5.2.x.+ '''+ self.policy_name = name+ self._policy_template_uuid(template)+ self._policy_edit_template(uuid=self.policy_template_uuid)+ try:+ self.policy_id = self.res["policy_id"]++ # prevent duplicate names when we build the scan+ self.policy_name = self.res["policy_name"]++ except KeyError:+ print("policy_id was not returned. Exiting")+ sys.exit(1)++ self.policy_add_creds(credentials=credentials)+ self._policy_set_settings()++ if plugins != None:+ self.plugins_info(plugins=plugins)+ self._enable_plugins()++################################################################################+ def policy_copy(self, existing_policy_name, new_policy_name):+ '''+ Create a copy of an existing policy and set it to be used for a scan+ '''+ self.action(action="policies", method="GET")++ for policy in self.res["policies"]:+ if policy["name"] == existing_policy_name:+ self.action(action="policies/" + str(policy["id"]) + "/copy", method="POST")+ self.policy_id = self.res["id"]++ '''+ If there is a name conflict the rename appends a+ number to the requested name.+ '''+ self.policy_name = new_policy_name+ self.action(action="policies/" + str(self.policy_id), method="PUT",+ extra={"settings":{"name": self.policy_name}})+ return True++ return False++################################################################################+ def policy_delete(self, name):+ '''+ Delete a policy.+ '''+ self.action(action="policies", method="GET")++ for policy in self.res["policies"]:+ if policy["name"] == name:+ self.action(action="policies/" + str(policy["id"]), method="DELETE")+ return True++ return False++################################################################################+ def policy_exists(self, name):+ '''+ Set existing policy to use for a scan.+ '''+ self.policy_name = name+ self.action(action="policies", method="GET")++ if not self.res["policies"]:+ return False+ else:+ for policy in self.res["policies"]:+ if policy["name"] == name:+ self.policy_id = policy["id"]+ return True++ return False++################################################################################+ def policy_set(self, name):+ '''+ Set existing policy to use for a scan.+ '''+ self.policy_name = name+ self.action(action="policies", method="GET")++ for policy in self.res["policies"]:+ if policy["name"] == name:+ self.policy_id = policy["id"]+ break++ if not self.policy_id:+ print("no policy with name %s found. Exiting" % name)+ sys.exit(1)++################################################################################+ def policy_details(self, policy_id):+ '''+ Retrieves details of an existing policy.+ '''+ self.policy_id = policy_id+ self.action(action="policies/" + str(self.policy_id), method="GET")+ return self.res++################################################################################+ def _policy_edit_template(self, uuid):+ '''+ Using the UUID, create the base policy, which will then be manipulated.+ This is easier than attempting to design an entire policy in one call.+ '''+ extra = {"settings": {"name": self.policy_name}, "uuid": uuid}+ self.action(action="policies", method="POST", extra=extra)++################################################################################+ def policy_add_ports(self, ports):+ '''+ Read current ports and append needed ports. The current value could have+ been gathered when disabling the plugin families, but for the sake of an+ extra call, it is much more clear what is occurring.+ '''++ discovery = {}+ default_ports = ""++ self.action(action="editor/policy/" + str(self.policy_id), method="GET")+ for inputs in self.res["settings"]["discovery"]["groups"]:+ if inputs["name"] == "network_discovery":+ discovery = inputs["sections"]++ for item in discovery:+ for nested in item["inputs"]:+ if nested["id"] == "portscan_range":+ default_ports = nested["default"]++ new_ports = str(default_ports) + "," + str(ports)+ extra = {"settings": {"portscan_range": new_ports}}+ self.action(action="policies/" + str(self.policy_id), method="PUT",+ extra=extra)++###############################################################################+ def policy_limit_ports(self, ports):+ '''+ Limit the ports scanned to the given list.+ '''+ extra = {"settings": {"portscan_range": str(ports)}}+ self.action(action="policies/" + str(self.policy_id), method="PUT",+ extra=extra)++################################################################################+ def policy_add_creds(self, credentials, policy_id=""):+ '''+ Add a list of credentials, defined using the objects in the credential+ module.+ '''+ if not policy_id:+ policy_id = self.policy_id++ creds = collections.defaultdict(lambda: collections.defaultdict(list))++ for credential in credentials:+ creds[credential.category][credential.name].append(credential.__dict__)++ creds = {"credentials": {"add": creds}}+ self.action(action="policies/" + str(policy_id),+ method="PUT", extra=creds)++################################################################################+ def _policy_set_settings(self):+ '''+ Current settings include: safe_checks, scan_webapps, report_paranoia,+ provided_creds_only, thorough_tests, report_verbosity,+ silent_dependencies+ '''+ settings = {"settings": {}}++ # Default to safe checks+ # Values: yes, no+ if not self.set_safe_checks:+ self.set_safe_checks = "yes"++ # Default to not scanning webapps+ # Values: yes, no+ if not self.pref_cgi:+ self.pref_cgi = "no"++ # Default to normal paranoia levels+ # Values: Avoid false alarms, Normal, Paranoid+ if not self.pref_paranoid:+ self.pref_paranoid = "Normal"++ # Default to allow scans to check for default credentials+ # Values: yes, no+ if not self.pref_supplied:+ self.pref_supplied = "no"++ # Default to not use thorough tests+ # Values: yes, no+ if not self.pref_thorough:+ self.pref_thorough = "no"++ # Default to normal verbosity.+ # Values: Quiet, Normal, Verbose+ if not self.pref_verbose:+ self.pref_verbose = "Normal"++ # Default to normal reporting of dependencies+ # Values: yes, no+ if not self.pref_silent_dependencies:+ self.pref_silent_dependencies = "yes"++ # Plugin receive timeout limit+ # Values: positive integers, passed as strings+ # Nessus default: 5+ if not self.pref_receive_timeout:+ self.pref_receive_timeout = "5"++ # Maximum concurrent checks+ # Values: positive integers, passed as strings+ # Nessus default: 5+ if not self.pref_max_checks:+ self.pref_max_checks = "5"++ settings["settings"].update({"safe_checks": self.set_safe_checks})+ settings["settings"].update({"scan_webapps": self.pref_cgi})+ settings["settings"].update({"report_paranoia": self.pref_paranoid})+ settings["settings"].update({"provided_creds_only": self.pref_supplied})+ settings["settings"].update({"thorough_tests": self.pref_thorough})+ settings["settings"].update({"report_verbosity": self.pref_verbose})+ settings["settings"].update({"silent_dependencies":+ self.pref_silent_dependencies})+ settings["settings"].update({"cisco_offline_configs":+ self.cisco_offline_configs})+ settings["settings"].update({"network_receive_timeout":+ self.pref_receive_timeout})+ settings["settings"].update({"max_checks_per_host":+ self.pref_max_checks})++ self.action(action="policies/" + str(self.policy_id), method="PUT",+ extra=settings)++################################################################################+ def _policy_remove_audits(self, category, type='custom'):+ '''+ Removes all audit files from the policy.+ '''+ delete_ids = []++ self.action(action="editor/policy/" + str(self.policy_id),+ method="GET")++ for record in self.res['compliance']['data']:+ if record['name'] == category:+ for audit in record['audits']:+ if audit['type'] == type and 'id' in audit:+ delete_ids.append(str(audit['id']))++ audit = {"audits": {"custom": {"delete": []}}}+ if len(delete_ids) > 0:+ audit["audits"]["custom"]["delete"] = delete_ids++ self.action(action="policies/" + str(self.policy_id),+ method="PUT", extra=audit)++################################################################################+ def _policy_add_audit(self, category, filename):+ '''+ Adds an audit file to the policy.+ '''+ audit = {"audits": {"custom": {"add": []}}}+ audit["audits"]["custom"]["add"].append(+ {"file": filename,+ "category": category})++ self.action(action="policies/" + str(self.policy_id),+ method="PUT", extra=audit)++################################################################################+ def plugins_info(self, plugins):+ '''+ Gather information on plugins for reporting. This also ensures that the+ plugin exists, and exits if it does not.+ '''+ for plugin in plugins.split(','):+ self.action(action="plugins/plugin/" + str(plugin), method="GET")++ if "attributes" in self.res:+ for attrib in self.res["attributes"]:+ if attrib["attribute_name"] == "fname":+ self.plugins.update({str(plugin):+ {"fname":+ attrib["attribute_value"],+ "name": self.res["name"]}})+ else:+ # We don't want to scan with plugins that don't exist.+ print ("Plugin with ID %s is not found. Exiting." % plugin)+ sys.exit(1)++################################################################################+ def _enable_plugins(self, plugins=[]):+ '''+ Disable all of the families, and then enable plugins that you need. This+ builds the entire "plugins" object, and can be very large for some+ families, such as "AIX", as it needs to make an entry for each plugin in+ the family to set the status.+ '''+ families = {"plugins": {}}+ updates = {}+ family_id = {}++ self.action(action="editor/policy/" + str(self.policy_id), method="GET")++ # Build an object to disable all plugins at the family level.+ for item in self.res["plugins"]["families"]:+ families["plugins"].update({item: {"status": "disabled"}})++ # print(json.dumps(families, sort_keys=False, indent=4))+ self.action(action="policies/" + str(self.policy_id),+ method="PUT", extra=families)++ # Query the search interface to get the family information for the+ # plugin+ for plugin in self.plugins.keys():+ self.action(action="editor/policy/" + str(self.policy_id) ++ "/families?filter.search_type=and&" ++ "filter.0.filter=plugin_id&filter.0.quality=eq&" ++ "filter.0.value=" + str(plugin), method="GET")++ for family in self.res["families"]:+ # if family not in updates:+ if family not in updates:+ # Add the key if it isn't in the dict+ updates.update({family: []})++ # Add the plugin to the list of the family+ updates[family].append(plugin)++ # Track the family ID so we can request the list of plugins+ family_id.update({family:+ str(self.res["families"][family]["id"])})++ # Build the stub for a family that has individual plugins enabled+ for fam, fam_id in family_id.items():+ families["plugins"][fam].update({"status": "mixed"})+ families["plugins"][fam].update({"individual": {}})+ self.action(action="editor/policy/" + str(self.policy_id) ++ "/families/" + str(fam_id), method="GET")++ # Disable every plugin in the family+ all_disabled = {}+ for pid in self.res["plugins"]:+ all_disabled.update({str(pid["id"]): "disabled"})++ # Update the "plugins" object to have all individual plugins+ # disabled+ families["plugins"][fam]["individual"].update(all_disabled)++ # Update each of the plugins that we have selected to enable+ for fam, pids in updates.items():+ for pid in pids:+ families["plugins"][fam]["individual"].update({str(pid):+ "enabled"})++ self.action(action="policies/" + str(self.policy_id),+ method="PUT", extra=families)++################################################################################+ def scan_add(self, targets, template="custom", name="", start=""):+ '''+ After building the policy, create a scan.+ '''+ self._scan_template_uuid(name=template)+ self._scan_tag()++ # This makes the targets much more readable in the GUI, as it splits+ # them out to "one per line"+ text_targets = targets.replace(",", "\n")++ self.targets = targets.replace(",", " ")++ # Figure out scan name+ if name:+ self.scan_name = name+ else:+ self.scan_name = self.policy_name++ scan = {"uuid": self.scan_template_uuid}+ settings = {}++ # Static items- some could be dynamic, but it's overkill+ settings.update({"launch": "ON_DEMAND"})+ settings.update({"description": "Created with REST API"})+ settings.update({"file_targets": ""})+ settings.update({"filters": []})+ settings.update({"emails": ""})+ settings.update({"filter_type": ""})++ # Dynamic items+ settings.update({"scanner_id": str(self.scanner_id)})+ settings.update({"name": self.scan_name})++ if self.policy_id:+ settings.update({"policy_id": self.policy_id})++ settings.update({"folder_id": self.tag_id})+ settings.update({"text_targets": text_targets})++ # Start a scan at a scheduled time+ if start:+ settings.update({"starttime": start})+ settings.update({"rrules": "FREQ=ONETIME"})+ scan.update({"settings": settings})++ self.action(action="scans", method="POST", extra=scan)++ # This is the scan template UUID, this will be overwritten when we run+ # the actual scan. Storing this value is mainly for debugging. If+ # something was to go wrong, and we called "objdump", seeing+ # "template-..." would be an obvious indicator of our location in+ # creating the scan.+ self.scan_uuid = self.res["scan"]["uuid"]++ # We use the id for building the "launch" URL+ self.scan_id = self.res["scan"]["id"]++################################################################################+ def scan_delete(self, name):+ '''+ Delete a scan.+ '''++ # Find the scan id based on the name+ self.action(action="scans", method="GET")++ for scan in self.res["scans"]:+ if scan["name"] == name:+ self.action(action="scans/" + str(scan["id"]), method="DELETE")+ return True++ return False++################################################################################+ def scan_exists(self, name):+ '''+ Set existing scan.+ '''+ self.scan_name = name+ self.action(action="scans", method="GET")++ if "scans" in self.res and self.res["scans"]:+ for scan in self.res["scans"]:+ if scan["name"] == name:+ self.scan_id = scan["id"]+ return True++ return False++################################################################################+ def scan_update_targets(self, targets):+ '''+ After update targets on existing scan.+ '''++ # This makes the targets much more readable in the GUI, as it splits+ # them out to "one per line"+ text_targets = targets.replace(",", "\n")++ self.targets = targets.replace(",", " ")++ self.action(action="scans/" + str(self.scan_id), method="GET")++ #scan = {"uuid": self.scan_uuid}+ scan = {}+ settings = {}++ # Static items- some could be dynamic, but it's overkill++ # Dynamic items+ settings.update({"name": self.scan_name})+ settings.update({"policy_id": self.policy_id})+ settings.update({"folder_id": self.tag_id})+ settings.update({"text_targets": text_targets})++ scan.update({"settings": settings})++ self.action(action="scans/" + str(self.scan_id), method="PUT", extra=scan)+++################################################################################+ def scan_run(self):+ '''+ Start the scan and save the UUID to query the status+ '''+ self.action(action="scans/" + str(self.scan_id) + "/launch",+ method="POST")++ self.scan_uuid = self.res["scan_uuid"]++ print("Scan name : %s" % self.scan_name)+ print("Scan UUID : %s" % self.scan_uuid)++################################################################################+ def _scan_status(self):+ '''+ Check on the scan every 2 seconds.+ '''+ running = True+ counter = 0++ while running:+ self.action(action="scans?folder_id=" + str(self.tag_id),+ method="GET")++ for scan in self.res["scans"]:+ if (scan["uuid"] == self.scan_uuid+ and (scan['status'] == "running" or scan['status'] == "pending")):++ sys.stdout.write(".")+ sys.stdout.flush()+ time.sleep(2)+ counter += 2++ if counter % 60 == 0:+ print("")++ if (scan["uuid"] == self.scan_uuid+ and scan['status'] != "running" and scan['status'] != "pending"):++ running = False++ # Yes, there are timestamps that we can use to compute the+ # actual running time, however this is just a rough metric+ # that's more to get a feel of how long something is taking,+ # it's not meant for precision.+ print("\nComplete! Run time: %d seconds." % counter)+++################################################################################+ def _scan_tag(self, name="CLI"):+ '''+ Set the 'tag' for the scan to CLI, if the tag doesn't exist, create it+ and use the resulting ID+ '''+ # Default to "CLI"+ if not self.tag_name:+ self.tag_name = name++ self.action(action="folders", method="GET")++ # Get the numeric ID of the tag. This is used to tag where the scan will+ # live in the GUI, as well as help filter the "scan_status" queries and+ # limit traffic/results processing.+ for tag in self.res["folders"]:+ if tag["name"] == self.tag_name:+ self.tag_id = tag["id"]+ break++ # Create the new tag if it doesn't exist+ if not self.tag_id:+ self.action("folders", method="POST", extra={"name": self.tag_name})+ self.tag_id = self.res["id"]++################################################################################+ def scan_details(self, name):+ '''+ Fetch the details of the requested scan+ '''++ # Find the scan id based on the name+ self.action(action="scans", method="GET")++ for scan in self.res["scans"]:+ if scan["name"] == name:+ self.scan_id = scan["id"]+ break++ if not self.scan_id:+ print("no scan with name %s found. Exiting" % name)+ sys.exit(1)++ # Get the details of the scan+ self.action(action="scans/" + str(self.scan_id), method="GET")+ return self.res++################################################################################+ def scan_list(self):+ '''+ Fetch a list with scans+ '''+ self.action(action="scans", method="GET")+ return self.res++################################################################################+ def scan_list_from_folder(self, folder_id):+ '''+ Fetch a list with scans from a specified folder+ '''++ # Find the scan id based on the name+ self.action(action="scans/?folder_id=" + str(folder_id), method="GET")++ return self.res++################################################################################+ def get_host_vulns(self, name):+ '''+ Fill in host_vulns dict with the host vulnerabilities found in a+ scan+ '''++ # Get details of requested scan+ self.scan_details(name)++ for host in self.res["hosts"]:+ self.action(action="scans/" + str(self.scan_id) + "/hosts/" + str(host["host_id"]), method="GET")+ #print("scans/" + str(self.scan_id)+ "/hosts/" +str(host["host_id"]))+ if self.scan_id not in self.host_vulns:+ self.host_vulns[self.scan_id] = {}+ self.host_vulns[self.scan_id][host["host_id"]]=self.res++################################################################################+ def get_host_ids(self, name):+ '''+ List host_ids in given scan+ '''++ # Get details of requested scan+ self.scan_details(name)++ for host in self.res["hosts"]:+ #print("%s" % host["host_id"])+ self.host_ids[host["host_id"]]=1++################################################################################+ def get_host_details(self, scan_id, host_id):+ '''+ Fill in host_details dict with the host vulnerabilities found in a+ scan+ '''++ # Get details of requested scan++ self.action(action="scans/" + str(scan_id) + "/hosts/" + str(host_id), method="GET")+ if scan_id not in self.host_details:+ self.host_details[scan_id] = {}+ self.host_details[scan_id][host_id]=self.res++################################################################################+ def get_plugin_output(self, scan, plugin_id):+ '''+ Fill in plugin_output dict with the output from a given plugin+ in a given scan+ '''+ # Make sure the supplied plugin_id is of type int+ plugin_id = int(plugin_id)++ # Get list of host vulns+ self.get_host_vulns(scan)++ for scan_id in self.host_vulns:+ for host_id in self.host_vulns[scan_id]:+ for vulnerability in self.host_vulns[scan_id][host_id]["vulnerabilities"]:+ if vulnerability["plugin_id"] == plugin_id:+ self.action(action="scans/" + str(scan_id) + "/hosts/" + str(host_id) + "/plugins/" + str(plugin_id), method="GET")+ if scan_id not in self.plugin_output:+ self.plugin_output[scan_id] = {}+ self.plugin_output[scan_id][host_id]=self.res++################################################################################+ def _deduplicate_hosts(self, hosts):+ return list({v["hostname"]: v for v in hosts}.values())++################################################################################+ def download_kbs(self):+ self.action("scans/" + str(self.scan_id), method="GET")++ # Merge vulnerability and compliance hosts into a list, unique by+ # hostname.+ merged_hosts = self.res.get("hosts", []) + self.res.get("comphosts", [])+ hosts = self._deduplicate_hosts(hosts=merged_hosts)+ kbs = {}+ for host in hosts:+ kbs[host["hostname"]] = self.action("scans/" + str(self.scan_id) ++ "/hosts/" + str(host["host_id"]) ++ "/kb?token=" + str(self.token),+ method="GET",+ download=True)++ return kbs++################################################################################+ def download_scan(self, export_format="", chapters="", dbpasswd=""):+ running = True+ counter = 0++ self.action("scans/" + str(self.scan_id), method="GET")+ if (export_format=="db"):+ data = {"format":"db","password":dbpasswd}+ elif (export_format=="html"):+ data = {"format":export_format,"chapters":chapters}+ else:+ data = {'format': export_format}+ self.action("scans/" + str(self.scan_id) + "/export",+ method="POST",+ extra=data)++ file_id = self.res['file']+ print('Download for file id '+str(self.res['file'])+'.')+ while running:+ time.sleep(2)+ counter += 2+ self.action("scans/" + str(self.scan_id) + "/export/"+ + str(file_id) + "/status",+ method="GET")+ running = self.res['status'] != 'ready'+ sys.stdout.write(".")+ sys.stdout.flush()+ if counter % 60 == 0:+ print("")++ print("")++ content = self.action("scans/" + str(self.scan_id) + "/export/"+ + str(file_id) + "/download",+ method="GET",+ download=True)+ return content++################################################################################+ def scan_results(self):+ '''+ Get the list of hosts, then iterate over them and extract results+ '''++ # Check the status, we will be in a "wait" until the scan completes+ self._scan_status()++ # Query the completed scan and parse results+ self.action("scans/" + str(self.scan_id), method="GET")++ for host in self.res["hosts"]:+ if self.format_start:+ print(self.format_start)++ print("----------------------------------------")+ print("Target : %s" % host["hostname"])+ print("----------------------------------------\n")++ for plugin in self.plugins.keys():+ self.action("scans/" + str(self.scan_id) + "/hosts/" ++ str(host["host_id"]) + "/plugins/" + str(plugin),+ method="GET")++ # If not defined, the plugin did not fire for the host+ if self.res["outputs"]:++ print("Plugin Name : " + self.plugins[plugin]["name"])+ print("Plugin File : " + self.plugins[plugin]["fname"])+ print("Plugin ID : %s" % plugin)+ print("Plugin Output :")++ for output in self.res["outputs"]:+ if 'plugin_output' in output:+ print(output["plugin_output"])+ else:+ print("Success")+ print()++ # The 6.x Audit Trail has less information than previous+ # versions(no plugin name). This information could be captured+ # during the call to "_enable_plugins", and stored, but is+ # somewhat limited in utility.+ self.action("scans/" + str(self.scan_id) ++ "/trails/?plugin_id=" + str(plugin) + "&hostname=" ++ host["hostname"], method="GET")++ # New syntax for 6.4+ try:+ if self.res["trails"]:+ for output in self.res["trails"]:+ print("Plugin Name : " + self.plugins[plugin]["name"])+ print("Plugin File : " + self.plugins[plugin]["fname"])+ print("Plugin ID : %s" % plugin)+ print("Audit trail : " + output["output"])+ print()+ except:+ pass++ if self.format_end:+ print(self.format_end)+ try:+ if self.res is not None:+ for host in self.res["comphosts"]:+ print("----------------------------------------")+ print("Target : %s" % host["hostname"])+ print("----------------------------------------\n")++ for plugin in self.res["compliance"]:+ self.action("scans/" + str(self.scan_id) + "/hosts/" ++ str(host["host_id"]) + "/compliance/" ++ str(plugin['plugin_id']), method="GET")+ self.pretty_print()+ except:+ pass++################################################################################+ def upload(self, upload_file, file_contents=""):+ '''+ Upload a file that can be used to import a policy or add an audit file+ to a policy. If file_contents are not provided then upload_file is+ treated as a full path to a file and opened.+ '''+ if not file_contents:+ file_contents = open(upload_file, 'rb')+ upload_file = os.path.basename(upload_file)++ files = {'Filename': upload_file,+ 'Filedata': file_contents}++ self.action(action="file/upload",+ method="POST",+ files=files,+ json_req=False)++################################################################################+ def policy_import(self, filename):+ '''+ Import a previously uploaded .nessus file as a policy.+ '''+ data = {'file': filename}+ self.action(action="policies/import",+ method="POST",+ extra=data)+ print("Imported policy named '%s', id %s" % (self.res['name'],+ self.res['id']))+ return self.res['id']++################################################################################+ def pretty_print(self):+ '''+ Used for debugging and error conditions to easily see the returned+ structure.+ '''+ print(json.dumps(self.res, sort_keys=False, indent=2))+ print("\n")++################################################################################+ def objdump(self):+ '''+ debugging function to dump all of the set values+ '''+ for attr in dir(self):+ print("obj.%s = %s" % (attr, getattr(self, attr)))+++if __name__ == "__main__":++ print("Import the module, do not call directly.")