Nessus Scan Information

#TRUSTED 15daeb8b7cdf8ac320111e5c59c1c9d567450a583450fadbcd9aaa5628bba968dc3381c28d953f9dcc4ae2d81ef7c235b1ff7ab9f2ded4ef2b3606d6108cd271c9d3ded147598f3e6e8ae5c2d6ef12d1c94a54189fc3bc88a085536eb3181727edfbeacc161c8d51433c35599e0b6891384182d2e6de37eaa0722bff9170e1401b41b281e4aa1117588cefc308783c9360ed80a05a2d734ca6e7604692a9e4374e7e9eb6abae646fdab5cf0422d110fc1545721f1bcdf452f1b264295b4807419deab29138c8acbf7fbf05c7230184da550e28cd844796361b5d9db1ef242418d8ecd0eb616b79957236ca419341ff5ea7981d2572f848c70e6c8e5cf23d8153abe40e9050512fde6423bbb184abb34c6d66d868c5b757122b7b02fc11b147dc04c31cdf37465cc05124e4cb34366bf3134549ca9bf3160f518ca89e7ec2e1c642aeefeeaf977ee93a1642763e1958821f5a025d06116c0fd39aa39cce9afda8961e82b4fab661ce6493fbfd41ed0bd0d180bbc1cb6dc2f242fd8fbc5dd29f9403f5e4ed37cf7c57bbc4f9835bae7b9d706182da6a1783031a3aa233f31cf27812f0c244b165f9c5a833569df37b58cf055f4ab88e4f375e7fb975e8336343f99967553846749ff4418554b4e345af0b9ae56f166061d719b34db0ae36426ae2e07caeca781f667d21fb8b357c53530c02c899169c685d8a079896c5f48fd3a6
#TRUST-RSA-SHA256 75ffaed690c6248d5382a7205a968227e32c6a013012da4e1ead9f2f265e98b54d764f0a2d285be1ac7a73b78a944c15c640561dc1be7d438bda93004149366998139a72fb1bf2d493e613573609933cdcc64af0666d90770fb55cd4ff3123af508e59af8043fadba724df3b7e79bc7f5f14a77e79502cdbaa585da3d334291f42289ea420a7ed0fa2872720fc82e5825402bd22f318543abd6a9141d5d6a66598613750a401a21928d58519a8e3e338828693b43a718d287833806876540e782d4b1daab035023f4014e41c5c31c58d4e660f24b504f43f1230bd1a18d9cc925608fcaacf9a19c647a88266e0716b723919328e6a70697b253fced73970bfead91baf4423f7b639291a59870ac8fe2c1a979fe4424aafd5de4446ef4d864e7d504df58ab2a4c1592b279ec0655c72572caa4f1e68e257593e56cf53e5593f0cab35aff882c37556c21833a06ee134ccc017d9686417f96d52cdf7866b9dcc7894febf6875250b8bef183f35dc12578571e8026e76af2a9ac3162f3650ab989a93cc0632d419b2fa77fbfdf4f029363d0a99ac4251cc8323431190038a5f3a37e5bc08ab838fecc15bf10856f1a4ac128fa4274c6b6341bee27550bb686d2c2a257b162a4b25e4749f850594f1f40e27f7d5c27888aed1644f7a3c900ea46c6e03ef519f70c0586ccef9916749f60d6eaabfbd1ff3bf8b67424282c2faaf772c
#%NASL_MIN_LEVEL 70300

#
# (C) Tenable Network Security, Inc.
#

include('deprecated_nasl_level.inc');
include("compat.inc");

if (description)
{
  script_id(19506);
  script_version("1.125");
  script_set_attribute(attribute:"plugin_modification_date", value:"2024/07/17");

  script_name(english:"Nessus Scan Information");

  script_set_attribute(attribute:"synopsis", value:
"This plugin displays information about the Nessus scan.");
  script_set_attribute(attribute:"description", value:
"This plugin displays, for each tested host, information about the
scan itself :

  - The version of the plugin set.
  - The type of scanner (Nessus or Nessus Home).
  - The version of the Nessus Engine.
  - The port scanner(s) used.
  - The port range scanned.
  - The ping round trip time 
  - Whether credentialed or third-party patch management
    checks are possible.
  - Whether the display of superseded patches is enabled
  - The date of the scan.
  - The duration of the scan.
  - The number of hosts scanned in parallel.
  - The number of checks done in parallel.");
  script_set_attribute(attribute:"solution", value:
"n/a");
  script_set_attribute(attribute:"agent", value:"all");
  script_set_attribute(attribute:"always_run", value:TRUE);
  script_set_attribute(attribute:"risk_factor", value:"None");

  script_set_attribute(attribute:"plugin_publication_date", value:"2005/08/26");

  script_set_attribute(attribute:"plugin_type", value:"summary");
  script_set_attribute(attribute:"thorough_tests", value:"true");
  script_end_attributes();

  script_category(ACT_END2);
  script_family(english:"Settings");

  script_copyright(english:"This script is Copyright (C) 2005-2024 and is owned by Tenable, Inc. or an Affiliate thereof.");

  script_dependencies("nessus_product_setup.nasl", "patches_summary.nbin");

  exit(0);
}

include('nessusd_product_info.inc');
include('smb_hotfixes.inc');
include('smb_func.inc');
include('agent.inc');
include('http.inc');
include('ssl_funcs.inc');

var rel, NESSUS6, nes_ver, nes_level, myVersion, plugin_feed_info, array, new_vers, list, version, unsupported_version,
acas_info, report, myPluginFeed, time, diff, old_feed, n_prod, scan_type, policy_name, policy_name2, range, ping_rtt,
modulus, local_checks, login_used, systemroot, proto_used, now, pmchecks, tool, report_superseded, opt, post_scan_editing,
start, zero, scan_duration, num_unsupported, i, cpe_base, old_feed_alert;

##
# Obtain the public ip address from the aws IMDSv2 service
##
function get_aws_metadata_public_ipv4()
{
  var AWS_IMDSv2_SERVICE_IP = "169.254.169.254";
  var AWS_IMDSv2_SERVICE_PORT = 80;

  # Get the IMDSv2 Token

  var AWS_TOKEN_URL = "/latest/api/token";
  var TOKEN_HEADERS = {
    "X-aws-ec2-metadata-token-ttl-seconds": "21600"
  };

  var latest_api_token_res =  http_send_recv3(
    target       : AWS_IMDSv2_SERVICE_IP,
    port         : AWS_IMDSv2_SERVICE_PORT,
    method       : "PUT",
    item         : AWS_TOKEN_URL,
    add_headers  : TOKEN_HEADERS,
    transport    : ssl_transport(ssl:FALSE, verify:FALSE),
    exit_on_fail : FALSE
  );
  var token = latest_api_token_res[2];

  # Validate Token exists before attempting to get address
  if (empty_or_null(token)) return NULL;



  # Get the IMDSv2 latest ipv4 address

  var AWS_IPV4_URL = "/latest/meta-data/public-ipv4";
  var IPV4_HEADERS = {
    "X-aws-ec2-metadata-token": token
  };

  var latest_public_ipv4_res =  http_send_recv3(
    target       : AWS_IMDSv2_SERVICE_IP,
    port         : AWS_IMDSv2_SERVICE_PORT,
    method       : "GET",
    item         : AWS_IPV4_URL,
    add_headers  : IPV4_HEADERS,
    transport    : ssl_transport(ssl:FALSE, verify:FALSE),
    exit_on_fail : FALSE
  );
  var ipv4_address = latest_public_ipv4_res[2];

  return ipv4_address;
}


old_feed_alert = 0;
NESSUS6 = make_list(6,10,5);
nes_ver = nessus_version();
nes_level = NASL_LEVEL;
myVersion = NULL;

plugin_feed_info = nessusd_plugin_feed_info();

if(isnull(plugin_feed_info))
  plugin_feed_info = {};

if(isnull(plugin_feed_info["PLUGIN_SET"]))
  plugin_feed_info["PLUGIN_SET"] = "<error>";

if(isnull(plugin_feed_info["PLUGIN_FEED"]))
  plugin_feed_info["PLUGIN_FEED"] = "<error>";

if (!isnull(nes_ver))
{
  array = split(nes_ver, sep:'.', keep:FALSE);
  myVersion = make_list(int(array[0]), int(array[1]), int(array[2]));

  if ( myVersion[0] < NESSUS6[0] || (myVersion[0] == NESSUS6[0] && (myVersion[1] < NESSUS6[1] || (myVersion[1] == NESSUS6[1] && myVersion[2] < NESSUS6[2])))
  ) new_vers = NESSUS6[0] + "." + NESSUS6[1] + "." + NESSUS6[2];
}

#
# If no plugin has shown anything, exit and note
#
list = get_kb_list("Success/*");
if ( isnull(list) ) exit(0,"No scans were completed. No scan information to report.");


if ( ! strlen(nes_ver) )
{
  if ( ! defined_func("pread") && nes_level >= 2202 )
    version = "NeWT";
  else
    version = "Unknown (NASL_LEVEL=" + nes_level + ")";
}
else
  version = nes_ver;

unsupported_version = NULL;
if (!isnull(myVersion) && myVersion[0] < NESSUS6[0])
{
  unsupported_version = 'Your Nessus version ' + version + ' is no longer supported.\n' +
   'Please consider upgrading to ensure that results are complete.\n';
}

if ( new_vers )
 version += " (Nessus " + new_vers + ' is available.)\n';

var nasl_env = nasl_environment(flags:ENV_APP | ENV_RUNTIME | ENV_OS | ENV_SCAN);

acas_info = '';
report = 'Information about this scan : \n\n';
report += 'Nessus version : ' + version + '\n';
if (!empty_or_null(nasl_env.build))
  report += strcat('Nessus build : ', nasl_env.build, '\n');

if (!isnull(unsupported_version))
  report += unsupported_version + '\n';


if ( plugin_feed_info["PLUGIN_SET"] )
{
 if (  "Home" >< plugin_feed_info["PLUGIN_FEED"] )
   myPluginFeed = "Nessus Home";
 else
   myPluginFeed = "Nessus";

 report += 'Plugin feed version : ' + plugin_feed_info["PLUGIN_SET"]     + '\n';
 report += 'Scanner edition used : ' + myPluginFeed + '\n';
 set_kb_item(name: "PluginFeed/Version", value: plugin_feed_info["PLUGIN_SET"]);
 set_kb_item(name: "PluginFeed/Type", value: plugin_feed_info["PLUGIN_FEED"]);
 if ( plugin_feed_info["PLUGIN_SET"] =~ "^[0-9]*$" )
 {
  rel["year"] = int(substr(plugin_feed_info["PLUGIN_SET"], 0, 3));
  rel["mon"] = int(substr(plugin_feed_info["PLUGIN_SET"], 4, 5));
  rel["mday"] = int(substr(plugin_feed_info["PLUGIN_SET"], 6, 7));
  time = ((rel["year"] - 1970)*(24*3600*365)) +
      (rel["year"] - 1970)/4*24*3600;
  time += (rel["mon"]-1)*(12*3600*30+12*3600*31);
  time += rel["mday"]*(24*3600);
  diff = (unixtime() - time)/3600/24;
  if ( diff >= 30 && diff < 10000 )
  {
   old_feed_alert ++;
   old_feed = '\nERROR: Your plugins have not been updated since ' +
     rel["year"] + "/" + rel["mon"] + "/" + rel["mday"] + '\n' +
'Performing a scan with an older plugin set will yield out-of-date results and
produce an incomplete audit. Please run nessus-update-plugins to get the
newest vulnerability checks from Nessus.org.\n\n';
   report += old_feed;
  }
 }
}

# Scanner OS
if (!empty_or_null(nasl_env.os))
  report += strcat('Scanner OS : ' + nasl_env.os, '\n');

if (!empty_or_null(nasl_env.distro))
  report += strcat('Scanner distribution : ', nasl_env.distro, '\n');

n_prod = get_kb_item("nessus/product");
if (!isnull(n_prod))
{
  if (n_prod == PRODUCT_WIN_AGENT  )      scan_type = "Windows Agent";
  else if (n_prod == PRODUCT_UNIX_AGENT ) scan_type = "Unix Agent";
  else if (n_prod == PRODUCT_MAC_AGENT )  scan_type = "Mac Agent";
  else if (n_prod == PRODUCT_NESSUSD    ) scan_type = "Normal";
  else if (n_prod == PRODUCT_NESSUSD_NSX) scan_type = "Nessus in NSX environment";
  else scan_type = "Nessus product undetermined";
  report += 'Scan type : ' + scan_type + '\n';
}

var scan_name;
if (!empty_or_null(get_preference('sc_scan_display_name')))
  scan_name = get_preference('sc_scan_display_name');
else if (!empty_or_null(nasl_env.scan_name))
  scan_name = nasl_env.scan_name;

if (!empty_or_null(scan_name))
  report += strcat('Scan name : ', scan_name, '\n');

policy_name = get_preference("@internal@policy_name");
if ( strlen(policy_name) > 0 )
{
  acas_info += 'ScanPolicy:' + policy_name;
  report += 'Scan policy used : ' + policy_name + '\n';
}

if (defined_func("report_xml_tag"))
{
  policy_name2 = get_preference("sc_policy_name");
  if (strlen(policy_name2) == 0) policy_name2 = policy_name;
  if (strlen(policy_name2) > 0) report_xml_tag(tag:"policy-used", value:policy_name2);
}

if (get_kb_item("Host/msp_scanner"))
{
  # The public ip requests are here to test in production before 
  # we add the content to the reporting output. 

  var aws_metadata_ip = get_aws_metadata_public_ipv4();
  if (empty_or_null(aws_metadata_ip)) aws_metadata_ip = "empty or null";
  set_kb_item(name:"aws/metadata/public/ip", value:aws_metadata_ip);

  report += 'Scanner IP : tenable.io Scanner\n';
}
else
  report += 'Scanner IP : ' + compat::this_host()    + '\n';

var scanners;
if (!get_kb_item("nessus/product/local"))
{
  list = get_kb_list("Host/scanners/*");
  if ( ! isnull(list) )
  {
   foreach var item ( keys(list) )
   {
    item -= "Host/scanners/";
    scanners += item + ' ';
   }

   report += 'Port scanner(s) : ' + scanners + '\n';
  }
  else
   report += '\nWARNING : No port scanner was enabled during the scan. This may\nlead to incomplete results.\n\n';

  if ( get_kb_item("global_settings/disable_service_discovery") )
  {
   report += '\nWARNING: Service discovery has been disabled. The audit is incomplete.\n';
  }

  range = get_preference("port_range");
  if ( ! range ) range = "(?)";
  report += 'Port range : ' + range + '\n';
}

report += 'Ping RTT : ';
ping_rtt = get_kb_item("ping_host/RTT");
if (ping_rtt && ping_rtt > 0)
{
  modulus = ping_rtt % 1000;
  if (modulus == 0) modulus = "0";
  else if (modulus < 10) modulus = "00" + modulus;
  else if (modulus < 100) modulus = "0" + modulus;
  ping_rtt = (ping_rtt / 1000) + '.' + modulus + ' ms';
}
else
{
  ping_rtt = 'Unavailable';
}
report += ping_rtt + '\n';

report += 'Thorough tests : ';
if ( thorough_tests ) report += 'yes\n';
else report += 'no\n';

report += 'Experimental tests : ';
if ( experimental_scripts ) report += 'yes\n';
else report += 'no\n';

var unpatched_vulns = get_kb_item('global_settings/vendor_unpatched');
if (empty_or_null(unpatched_vulns))
    report += 'Scan for Unpatched Vulnerabilities : no\n';
else
{
  if (unpatched_vulns)
    report += 'Scan for Unpatched Vulnerabilities : yes\n';
  else
    report += 'Scan for Unpatched Vulnerabilities : no\n';
}

report += 'Plugin debugging enabled : ';
if ( !get_kb_item('global_settings/enable_plugin_debugging') ) report += 'no\n';
else report += 'yes (at debugging level ' + debug_level + ')\n';

report += 'Paranoia level : ';
report += report_paranoia + '\n';

report += 'Report verbosity : ';
report += report_verbosity + '\n';

report += 'Safe checks : ';
if ( safe_checks() ) report += 'yes\n';
else report += 'no\n';

report += 'Optimize the test : ';
if ( get_preference("optimize_test") == "yes" ) report += 'yes\n';
else report += 'no\n';

local_checks = FALSE;
login_used = get_kb_item("HostLevelChecks/login");

report += 'Credentialed checks : ';
if ( get_kb_item("Host/local_checks_enabled") )
{
  # 20220330: There are edge cases where SMB/not_windows will not write on a non-windows device,
  # but Host/windows_local_checks will write because it relies on SMB/not_windows.
  # Add another precautionary layer for a Host/Auth/SSH/*/Success KB key.
  if ( !get_kb_item("SMB/not_windows") && get_kb_item("Host/windows_local_checks") && empty_or_null(get_kb_list("Host/Auth/SSH/*/Success")) )
  {
    login_used = get_kb_item("HostLevelChecks/smb_login");
    #
    # Windows local checks are complex because the SMB Login *might* work but
    # access to C$ or the registry could fail
    #
    if ( get_kb_item("SMB/MS_Bulletin_Checks/Possible") )
    {
      local_checks = TRUE;
      report += 'yes';
      if (!isnull(login_used)) report += ", as '" + login_used + "' via SMB";
    }
    else
    {
      systemroot = hotfix_get_systemdrive(as_share:TRUE);
      if (get_kb_item("SMB/Registry/Enumerated") && (!isnull(systemroot) && get_kb_item("SMB/AccessibleShare/"+systemroot)))
      {
        local_checks = TRUE;
        report += 'yes';
        if (!isnull(login_used)) report += ", as '" + login_used + "' via SMB";
      }
      else
      {
        local_checks = FALSE;
        report += 'no';
      }
    }
  }
  else
  {
    # Not windows
    local_checks = TRUE;
    report += 'yes';

    # nb : from ssh_get_info.nasl
    proto_used = get_kb_item("HostLevelChecks/proto");
    if (!isnull(proto_used))
    {
      if (proto_used == 'local')
      {
        report += " (on the localhost)";
      }
      else if (!isnull(login_used))
      {
        report += ", as '" + login_used + "' via " + proto_used;
      }
      if ( nes_level >= 61100 )
      {
        report += '\nAttempt Least Privilege : ';
        if (get_kb_item("SSH/attempt_least_privilege")) report += 'yes';
        else report += 'no';
      }
    }
    # nb: from cisco_ios_version.nasl w/ SNMP
    else if (get_kb_item("Host/Cisco/IOS/Version"))
    {
      report += ", via SNMP";
    }
    # nb: from palo_alto_version.nbin, via REST API.
    else if (get_kb_item("Host/Palo_Alto/Firewall/Source"))
    {
      report += ", via HTTPS";
    }
  }
}
else if ( get_kb_item("SMB/MS_Bulletin_Checks/Possible") && !get_kb_item("Host/patch_management_checks") )
{
  local_checks = TRUE;
  report += 'yes';

  if (!isnull(login_used)) report += " (as '" + login_used + "' via SMB";
}
else if ( get_one_kb_item('Host/Nutanix/DataCollection/ran') && get_one_kb_item('Host/Nutanix/Data/Version') )
{
  local_checks = TRUE;
  report += 'yes';
  nutanix_user = get_one_kb_item('Secret/Nutanix/config/username');
  if (!empty_or_null(nutanix_user))
    report += ', as \'' + nutanix_user + '\'';
  report += ', via HTTPS';
}
else report += 'no';
report += '\n';

if (defined_func("report_xml_tag"))
{
  now = unixtime();
  if (local_checks)
  {
    report_xml_tag(tag:"Credentialed_Scan", value:"true");
    report_xml_tag(tag:"LastAuthenticatedResults", value:now);
    acas_info += '\nCredentialed_Scan:true';
    acas_info += '\nLastAuthenticatedResults:' + now + '\n';
  }
  else
  {
    report_xml_tag(tag:"Credentialed_Scan", value:"false");
    report_xml_tag(tag:"LastUnauthenticatedResults", value:now);
    acas_info += '\nCredentialed_Scan:false';
    acas_info += '\nLastUnauthenticatedResults:' + now + '\n';
  }
}

pmchecks = "";
if (get_kb_item("patch_management/ran"))
{
  tool = "";
  foreach tool (keys(_pmtool_names))
  {
    if (get_kb_item("patch_management/"+tool))
    {
      pmchecks += ", " + _pmtool_names[tool];
      if (local_checks || !tool) pmchecks += " (unused)";
      else tool = _pmtool_names[tool];
    }
  }
}
if (get_kb_item("satellite/ran"))
{
  pmchecks += ", Red Hat Satellite Server";
  if (local_checks) pmchecks += " (unused)";
}
report += 'Patch management checks : ';
if (pmchecks)
{
  pmchecks = substr(pmchecks, 2);
  report += pmchecks + '\n';
}
else report += 'None\n';

#Display superseded patches: no (supersedence plugin ran)
if (get_kb_item("Settings/report_superseded_patches"))
{
  report_superseded = "yes";
}
else
{
  report_superseded = "no";
}
if (get_kb_item("PatchSummary/Superseded"))
{
  report_superseded += " (supersedence plugin launched)";
}
else
{
  report_superseded += " (supersedence plugin did not launch)";
}

report += 'Display superseded patches : ' + report_superseded + '\n';

report += 'CGI scanning : ';
if (get_kb_item("Settings/disable_cgi_scanning")) report += 'disabled\n';
else report += 'enabled\n';

report += 'Web application tests : ';
if (get_kb_item("Settings/enable_web_app_tests"))
{
  report += 'enabled\n';
  # Display web app tests options
  opt = get_kb_item("Settings/HTTP/test_arg_values");
  report += 'Web app tests -  Test mode : ' + opt + '\n';

  report += 'Web app tests -  Try all HTTP methods : ';
  if (get_kb_item("Settings/HTTP/try_all_http_methods"))
    report += 'yes\n';
  else
    report += 'no\n';

  opt = get_kb_item("Settings/HTTP/max_run_time");
  report += 'Web app tests -  Maximum run time : ' + (int(opt) / 60) + ' minutes.\n';
  opt = get_kb_item("Settings/HTTP/stop_at_first_flaw");
  report += 'Web app tests -  Stop at first flaw : ' + opt + '\n';
}
else
{
  report += 'disabled\n';
}

report += 'Max hosts : ' + get_preference("max_hosts") + '\n';
report += 'Max checks : ' + get_preference("max_checks") + '\n';
report += 'Recv timeout : ' + get_preference("checks_read_timeout") + '\n';

if ( get_kb_item("general/backported")  )
  report += 'Backports : Detected\n';
else
  report += 'Backports : None\n';


post_scan_editing = get_preference("allow_post_scan_editing");
if ( post_scan_editing == "no" )
  report += 'Allow post-scan editing : No\n';
else
  report += 'Allow post-scan editing : Yes\n';

var nasl_no_signature_check = get_preference("nasl_no_signature_check");
if ( nasl_no_signature_check == "yes" || nasl_no_signature_check == "true" )
  report += 'Nessus Plugin Signature Checking : Disabled\n';
else
  report += 'Nessus Plugin Signature Checking : Enabled\n';

var audit_signature_check = get_preference("audit_file_signature_check");
if ( audit_signature_check == "yes" || audit_signature_check == "true" )
  report += 'Audit File Signature Checking : Enabled\n';
else
  report += 'Audit File Signature Checking : Disabled\n';

start = get_kb_item("/tmp/start_time");

if ( start )
{
  time = localtime(start);
  if ( time["min"] < 10 ) zero = "0";
  else zero = NULL;

  report += 'Scan Start Date : ' + time["year"] + '/' + time["mon"] + '/' + time["mday"] + ' ' + time["hour"] + ':' +
            zero + time["min"] + ' ' + getlocaltimezone() + '\n';
}

if ( ! start ) scan_duration = 'unknown';
else           scan_duration = (unixtime() - start) + " sec";
report += 'Scan duration : ' + scan_duration + '\n';

if ( defined_func("report_error") && old_feed_alert )
{
  report_error(title:"Outdated plugins",
               message:old_feed,
               severity:1);
}

if(get_preference("sc_disa_output") == "true")
{
  num_unsupported = get_kb_item("NumUnsupportedProducts");
  if(isnull(num_unsupported)) num_unsupported = 0;

  if(num_unsupported > 0)
    report += 'Unsupported products :';

  for (i=0; i<num_unsupported; i++)
  {
    cpe_base = get_kb_item("UnsupportedProducts/"+i+"/cpe_base");
    version = get_kb_item("UnsupportedProducts/"+i+"/version");
    if(version == "unknown")
      report += '\n  UnsupportedProduct:' + cpe_base;
    else
      report += '\n  UnsupportedProduct:' + cpe_base + ':' + version;
  }

  if(num_unsupported > 0) report += '\n';

  report += acas_info;
}

if(get_kb_item("ComplianceChecks/ran"))
{
  if (get_kb_item("ComplianceChecks/scan_info"))
    report += "Compliance checks: " + get_kb_item("ComplianceChecks/scan_info") + '\n';
  else
    report += 'Compliance checks: Yes\n';
}

var malware_scanning_setting = get_preference("Malicious Process Detection[checkbox]:enable_malware_scanning");
if (malware_scanning_setting != "yes")
  report += 'Scan for malware : no\n';
else
  report += 'Scan for malware : yes\n';

if(nessusd_is_unix_agent() || nessusd_is_mac_agent())
{
  report += 'Use Tenable Utilities for "find" and "unzip" : ';
  var tenable_utils = get_preference("use_tenable_utils");
  if(!isnull(tenable_utils) && tenable_utils == "yes")
  {
    report += 'yes';
    var performance = "high";
    var perf_setting = get_preference("scan_performance_mode");
    if(!isnull(perf_setting) && (perf_setting == "medium" || perf_setting == "low"))
      performance = perf_setting;
    report += " (performance " + performance + ')\n';
  }
  else
  {
    report += 'no\n';
  }
}

if ( old_feed_alert && !defined_func("report_error") )
{
  if ( nes_level < 3000 ) security_hole(port:0, data:report);
  else security_hole(port:0, extra:report);
}
else
{
  if ( nes_level < 3000 ) security_note(port:0, data:report);
  else security_note(port:0, extra:report);
}