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	notus_advisory
struct	skiron_advisory
struct	advisories

Typedefs
typedef enum advisory_type	advisory_type_t
typedef struct fixed_version	fixed_version_t
typedef struct version_range	version_range_t
typedef struct vulnerable_pkg	vuln_pkg_t
typedef struct notus_advisory	advisory_t
typedef struct skiron_advisory	skiron_advisory_t
typedef struct advisories	advisories_t

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

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 *	lsc_get_response (const char *pkg_list, const char *os)
	Sent the installed package list and OS to notus.
advisories_t *	lsc_process_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 100 of file table_driven_lsc.h.

advisory_t

typedef struct notus_advisory advisory_t

Definition at line 77 of file table_driven_lsc.h.

advisory_type_t

typedef enum advisory_type advisory_type_t

Definition at line 32 of file table_driven_lsc.h.

fixed_version_t

typedef struct fixed_version fixed_version_t

Definition at line 41 of file table_driven_lsc.h.

skiron_advisory_t

typedef struct skiron_advisory skiron_advisory_t

Definition at line 85 of file table_driven_lsc.h.

version_range_t

typedef struct version_range version_range_t

Definition at line 50 of file table_driven_lsc.h.

vuln_pkg_t

typedef struct vulnerable_pkg vuln_pkg_t

Definition at line 66 of file table_driven_lsc.h.

Enumeration Type Documentation

advisory_type

enum advisory_type

Enumerator
NOTUS
SKIRON

Definition at line 26 of file table_driven_lsc.h.

{
  NOTUS,
  SKIRON,
};

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

notus_advisory

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

Definition at line 589 of file table_driven_lsc.c.

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

References advisories::advisories, advisory_free(), advisories::count, NOTUS, advisories::skiron_advisories, skiron_advisory_free(), and advisories::type.

Referenced by call_rs_notus(), Ensure(), lsc_process_response_notus(), parse_notus(), and parse_skiron().

Here is the call graph for this function:

Here is the caller graph for this function:

lsc_get_response()

char * lsc_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 1012 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:

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:

lsc_process_response()

advisories_t * lsc_process_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 821 of file table_driven_lsc.c.

{
  JsonParser *parser = NULL;
  JsonReader *reader = NULL;
  GError *err = NULL;
 
  advisories_t *advisories = NULL;
 
  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))
    {
      advisories = lsc_process_response_notus (reader);
    }
  else if (json_reader_is_array (reader))
    {
      advisories = lsc_process_response_skiron (reader);
    }
  else
    {
      g_debug ("Unknown JSON response format");
    }
 
  if (reader)
    g_object_unref (reader);
  g_object_unref (parser);
 
  return advisories;
}

References len, lsc_process_response_notus(), and lsc_process_response_skiron().

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 1167 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: