table_driven_lsc.h File Reference

#include <glib.h>
#include <gvm/util/kb.h>

Include dependency graph for table_driven_lsc.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	fixed_version
	Fixed version. More...
struct	version_range
	Specify a version range. More...
struct	vulnerable_pkg
	Define a vulnerable package. More...
struct	advisory
struct	advisories

Typedefs
typedef struct fixed_version	fixed_version_t
typedef struct version_range	version_range_t
typedef struct vulnerable_pkg	vuln_pkg_t
typedef struct advisory	advisory_t
typedef struct advisories	advisories_t

Enumerations
enum	fixed_type { UNKNOWN , RANGE , SINGLE }
	Fixed version format. More...

Functions
void	advisories_free (advisories_t *advisories)
	Free()'s an advisories.
void	set_lsc_flag (void)
	Set lsc_flag to 1.
int	lsc_has_run (void)
	Get lsc_flag value.
int	run_table_driven_lsc (const char *, const char *, const char *, const char *, const char *)
	Publish the necessary data to start a Table driven LSC scan.
char *	notus_get_response (const char *pkg_list, const char *os)
	Sent the installed package list and OS to notus.
advisories_t *	process_notus_response (const gchar *resp, const size_t len)
	Process a json object which contains advisories and vulnerable packages.

Typedef Documentation

advisories_t

typedef struct advisories advisories_t

Definition at line 80 of file table_driven_lsc.h.

advisory_t

typedef struct advisory advisory_t

Definition at line 70 of file table_driven_lsc.h.

fixed_version_t

typedef struct fixed_version fixed_version_t

Definition at line 33 of file table_driven_lsc.h.

version_range_t

typedef struct version_range version_range_t

Definition at line 42 of file table_driven_lsc.h.

vuln_pkg_t

typedef struct vulnerable_pkg vuln_pkg_t

Definition at line 58 of file table_driven_lsc.h.

Enumeration Type Documentation

fixed_type

enum fixed_type

Fixed version format.

Enumerator
UNKNOWN
RANGE
SINGLE

Definition at line 19 of file table_driven_lsc.h.

{
  UNKNOWN, // Unknown
  RANGE,   // Range of version which fixed the package
  SINGLE,  // A single version with a specifier (gt or lt)
};

Function Documentation

advisories_free()

void advisories_free

(

advisories_t *

advisories

)

Free()'s an advisories.

Parameters

advisory

The advisories holder to be free()'ed. It free()'s all advisories members.

Definition at line 549 of file table_driven_lsc.c.

{
  if (advisories == NULL)
    return;
 
  for (size_t i = 0; i < advisories->count; i++)
    advisory_free (advisories->advisories[i]);
  advisories = NULL;
}

References advisories::advisories, advisory_free(), and advisories::count.

Referenced by call_rs_notus(), Ensure(), nasl_notus(), and process_notus_response().

Here is the call graph for this function:

Here is the caller graph for this function:

lsc_has_run()

int lsc_has_run

(

void

)

Get lsc_flag value.

Definition at line 48 of file table_driven_lsc.c.

{
  return lsc_flag;
}

References lsc_flag.

Referenced by attack_host().

Here is the caller graph for this function:

notus_get_response()

char * notus_get_response	(	const char *	pkg_list,
		const char *	os )

Sent the installed package list and OS to notus.

Parameters

pkg_list	Installed package list
os	The target's OS

Returns

String containing the server response or NULL Must be free()'ed by the caller.

Definition at line 918 of file table_driven_lsc.c.

{
  const char *server = NULL;
  char *json_pkglist;
  char *response = NULL;
  notus_info_t notusdata;
  long ret;
 
  // Parse the server and get the port, host, schema
  // and necessary information to build the message
  server = prefs_get ("openvasd_server");
  notusdata = init_notus_info (server);
 
  if (parse_server (&notusdata) < 0)
    {
      free_notus_info (notusdata);
      return NULL;
    }
 
  // Convert the package list string into a string containing json
  // array of packages
  if ((json_pkglist = make_package_list_as_json_str (pkg_list)) == NULL)
    {
      free_notus_info (notusdata);
      return NULL;
    }
 
  ret = send_request (notusdata, os, json_pkglist, &response);
  if (ret != 200)
    g_warning ("%ld: Error sending request to openvasd: %s", ret, response);
 
  free_notus_info (notusdata);
  g_free (json_pkglist);
 
  return response;
}

References free_notus_info(), init_notus_info(), make_package_list_as_json_str(), parse_server(), and send_request().

Referenced by call_rs_notus(), and nasl_notus().

Here is the call graph for this function:

Here is the caller graph for this function:

process_notus_response()

advisories_t * process_notus_response	(	const gchar *	resp,
		const size_t	len )

Process a json object which contains advisories and vulnerable packages.

@description This is the body string in response get from an openvasd server

Parameters

resp	String containing the json object to be processed.
len	String length.

Returns

a advisories_t struct containing all advisories and vulnerable packages. After usage must be free()'ed with advisories_free().

Definition at line 616 of file table_driven_lsc.c.

{
  JsonParser *parser = NULL;
  JsonReader *reader = NULL;
  GError *err = NULL;
 
  advisories_t *advisories = advisories_new ();
 
  parser = json_parser_new ();
  if (!json_parser_load_from_data (parser, resp, len, &err))
    {
      g_message ("Error parsing");
    }
 
  reader = json_reader_new (json_parser_get_root (parser));
 
  if (!json_reader_is_object (reader))
    {
      g_debug ("It is not an object");
      goto cleanup_advisories;
    }
 
  char **members = json_reader_list_members (reader);
 
  for (int i = 0; members[i]; i++)
    {
      advisory_t *advisory;
 
      if (!json_reader_read_member (reader, members[i]))
        {
          g_debug ("No member oid");
          goto cleanup_advisories;
        }
      if (!json_reader_is_array (reader))
        {
          g_debug ("Is not an array");
          goto cleanup_advisories;
        }
 
      advisory = advisory_new (g_strdup (members[i]));
 
      int count_pkgs = json_reader_count_elements (reader);
      g_debug ("There are %d packages for advisory %s", count_pkgs, members[i]);
      for (int j = 0; j < count_pkgs; j++)
        {
          vuln_pkg_t *pkg = NULL;
          char *name = NULL;
          char *installed_version = NULL;
          char *start = NULL;
          char *stop = NULL;
          char *version = NULL;
          char *specifier = NULL;
          enum fixed_type type = UNKNOWN;
 
          json_reader_read_element (reader, j);
          if (!json_reader_is_object (reader))
            {
              g_warning ("%s: Package %d of advisory %s is not an object",
                         __func__, j, members[i]);
              advisories_free (advisories);
              goto cleanup_advisories;
            }
 
          json_reader_read_member (reader, "name");
          name = g_strdup (json_reader_get_string_value (reader));
          json_reader_end_member (reader);
          g_debug ("name: %s", name);
 
          json_reader_read_member (reader, "installed_version");
          installed_version = g_strdup (json_reader_get_string_value (reader));
          json_reader_end_member (reader);
          g_debug ("installed_version: %s", installed_version);
 
          json_reader_read_member (reader, "fixed_version");
          g_debug ("Fixed_version has %d members",
                   json_reader_count_members (reader));
 
          // Version Range
          json_reader_read_member (reader, "start");
          start = g_strdup (json_reader_get_string_value (reader));
          json_reader_end_member (reader);
          json_reader_read_member (reader, "end");
          stop = g_strdup (json_reader_get_string_value (reader));
          json_reader_end_member (reader);
          g_debug ("start %s, end: %s", start, stop);
 
          // version and specifier
          json_reader_read_member (reader, "version");
          version = g_strdup (json_reader_get_string_value (reader));
          json_reader_end_member (reader);
          json_reader_read_member (reader, "specifier");
          specifier = g_strdup (json_reader_get_string_value (reader));
          json_reader_end_member (reader);
          g_debug ("version %s, specifier: %s", version, specifier);
 
          // end read fixes version member
          json_reader_end_member (reader);
 
          // end package element
          json_reader_end_element (reader);
 
          char *item1 = NULL, *item2 = NULL;
          if (start && stop)
            {
              type = RANGE;
              item1 = start;
              item2 = stop;
            }
          else if (version && specifier)
            {
              type = SINGLE;
              item1 = version;
              item2 = specifier;
            }
          else
            {
              g_warning ("%s: Error parsing json element", __func__);
              g_free (name);
              g_free (installed_version);
              g_free (item1);
              g_free (item2);
              advisories_free (advisories);
              goto cleanup_advisories;
            }
 
          pkg =
            vulnerable_pkg_new (name, installed_version, type, item1, item2);
          g_free (name);
          g_free (installed_version);
          g_free (item1);
          g_free (item2);
 
          advisory_add_vuln_pkg (advisory, pkg);
        }
      // end advisory
      json_reader_end_member (reader);
      advisories_add (advisories, advisory);
    }
 
cleanup_advisories:
  if (reader)
    g_object_unref (reader);
  g_object_unref (parser);
 
  return advisories;
}

References advisories_add(), advisories_free(), advisories_new(), advisory_add_vuln_pkg(), advisory_new(), len, name, RANGE, SINGLE, UNKNOWN, and vulnerable_pkg_new().

Referenced by call_rs_notus(), Ensure(), and nasl_notus().

Here is the call graph for this function:

Here is the caller graph for this function:

run_table_driven_lsc()

int run_table_driven_lsc	(	const char *	scan_id,
		const char *	ip_str,
		const char *	hostname,
		const char *	package_list,
		const char *	os_release )

Publish the necessary data to start a Table driven LSC scan.

If the gather-package-list.nasl plugin was launched, and it generated a valid package list for a supported OS, the table driven LSC scan which is subscribed to the topic will perform a scan an publish the the results to be handle by the sensor/client.

Parameters

scan_id	Scan Id.
kb
ip_str	IP string of host.
hostname	Name of host.

Returns

0 on success, less than 0 on error.

Definition at line 1057 of file table_driven_lsc.c.

{
  int err = 0;
  if (!os_release || !package_list)
    return 0;
 
  if (prefs_get ("openvasd_server"))
    {
      g_message ("Running Notus for %s via openvasd", ip_str);
      err = call_rs_notus (ip_str, hostname, package_list, os_release);
 
      return err;
    }
  else
    {
      gchar *json_str;
      gchar *topic;
      gchar *payload;
      gchar *status = NULL;
      int topic_len;
      int payload_len;
 
      // Subscribe to status topic
      err = mqtt_subscribe ("scanner/status");
      if (err)
        {
          g_warning ("%s: Error starting lsc. Unable to subscribe", __func__);
          return -1;
        }
      /* Get the OS release. TODO: have a list with supported OS. */
 
      json_str = make_table_driven_lsc_info_json_str (scan_id, ip_str, hostname,
                                                      os_release, package_list);
 
      // Run table driven lsc
      if (json_str == NULL)
        return -1;
 
      g_message ("Running Notus for %s", ip_str);
      err = mqtt_publish ("scanner/package/cmd/notus", json_str);
      if (err)
        {
          g_warning ("%s: Error publishing message for Notus.", __func__);
          g_free (json_str);
          return -1;
        }
 
      g_free (json_str);
 
      // Wait for Notus scanner to start or interrupt
      while (!status)
        {
          err = mqtt_retrieve_message (&topic, &topic_len, &payload,
                                       &payload_len, 60000);
          if (err == -1 || err == 1)
            {
              g_warning ("%s: Unable to retrieve status message from notus. %s",
                         __func__, err == 1 ? "Timeout after 60 s." : "");
              return -1;
            }
 
          // Get status if it belongs to corresponding scan and host
          // Else wait for next status message
          status = get_status_of_table_driven_lsc_from_json (
            scan_id, ip_str, payload, payload_len);
 
          g_free (topic);
          g_free (payload);
        }
      // If started wait for it to finish or interrupt
      if (!g_strcmp0 (status, "running"))
        {
          g_debug ("%s: table driven LSC with scan id %s successfully started "
                   "for host %s",
                   __func__, scan_id, ip_str);
          g_free (status);
          status = NULL;
          while (!status)
            {
              err = mqtt_retrieve_message (&topic, &topic_len, &payload,
                                           &payload_len, 60000);
              if (err == -1)
                {
                  g_warning (
                    "%s: Unable to retrieve status message from notus.",
                    __func__);
                  return -1;
                }
              if (err == 1)
                {
                  g_warning (
                    "%s: Unable to retrieve message. Timeout after 60s.",
                    __func__);
                  return -1;
                }
 
              status = get_status_of_table_driven_lsc_from_json (
                scan_id, ip_str, payload, payload_len);
              g_free (topic);
              g_free (payload);
            }
        }
      else
        {
          g_warning ("%s: Unable to start lsc. Got status: %s", __func__,
                     status);
          g_free (status);
          return -1;
        }
 
      if (g_strcmp0 (status, "finished"))
        {
          g_warning (
            "%s: table driven lsc with scan id %s did not finish successfully "
            "for host %s. Last status was %s",
            __func__, scan_id, ip_str, status);
          err = -1;
        }
      else
        g_debug ("%s: table driven lsc with scan id %s successfully finished "
                 "for host %s",
                 __func__, scan_id, ip_str);
      g_free (status);
    }
  return err;
}

References call_rs_notus(), get_status_of_table_driven_lsc_from_json(), hostname, make_table_driven_lsc_info_json_str(), payload, and scan_id.

Referenced by call_lsc().

Here is the call graph for this function:

Here is the caller graph for this function:

set_lsc_flag()

void set_lsc_flag

(

void

)

Set lsc_flag to 1.

Definition at line 40 of file table_driven_lsc.c.

{
  lsc_flag = 1;
}

References lsc_flag.

Referenced by process_ipc_data().

Here is the caller graph for this function: