openvasd.c

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2024 Greenbone AG
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

 
#include "openvasd.h"
 
#include "../base/array.h"
#include "../base/networking.h"
#include "../http/httputils.h"
#include "../http_scanner/http_scanner.h"
#include "../util/json.h"
 
#include <cjson/cJSON.h>
#include <netinet/in.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
#undef G_LOG_DOMAIN
#define G_LOG_DOMAIN "libgvm ovd"
 
#define RESP_CODE_ERR -1
#define RESP_CODE_OK 0

struct openvasd_target
{
  gchar *scan_id;        
  GSList *credentials;   
  gchar *exclude_hosts;  
  gchar *hosts;          
  gchar *ports;          
  gchar *finished_hosts; 
  openvasd_alive_test_methods_t alive_test_methods; 
  int reverse_lookup_unify; 
  int reverse_lookup_only;  
};

struct openvasd_vt_single
{
  gchar *vt_id;
  GHashTable *vt_values;
};

http_scanner_resp_t
openvasd_get_vt_stream_init (http_scanner_connector_t conn)
{
  GString *path;
  http_scanner_resp_t response = NULL;
 
  path = g_string_new ("/vts?information=1");
  response = http_scanner_init_request_multi (conn, path->str);
 
  g_string_free (path, TRUE);
 
  return response;
}

int
openvasd_get_vt_stream (http_scanner_connector_t conn)
{
  return http_scanner_process_request_multi (conn, 5000);
}

http_scanner_resp_t
openvasd_get_vts (http_scanner_connector_t conn)
{
  GString *path;
  http_scanner_resp_t response = NULL;
 
  path = g_string_new ("/vts?information=1");
  response =
    http_scanner_send_request (conn, HTTP_SCANNER_GET, path->str, NULL, NULL);
 
  g_string_free (path, TRUE);
 
  if (response->code != RESP_CODE_ERR)
    response->body = g_strdup (http_scanner_stream_str (conn));
 
  http_scanner_reset_stream (conn);
  return response;
}

http_scanner_resp_t
openvasd_get_performance (http_scanner_connector_t conn,
                          openvasd_get_performance_opts_t opts)
{
  http_scanner_resp_t response;
  gchar *query;
  time_t now;
 
  time (&now);
 
  if (!opts.titles || !strcmp (opts.titles, "") || opts.start < 0
      || opts.start > now || opts.end < 0 || opts.end > now)
    {
      response = g_malloc0 (sizeof (struct http_scanner_response));
      response->code = RESP_CODE_ERR;
      response->body =
        g_strdup ("{\"error\": \"Couldn't send get_performance command "
                  "to scanner. Bad or missing parameters.\"}");
      return response;
    }
 
  query = g_strdup_printf ("/health/performance?start=%d&end=%d&titles=%s",
                           opts.start, opts.end, opts.titles);
  response =
    http_scanner_send_request (conn, HTTP_SCANNER_GET, query, NULL, NULL);
  g_free (query);
 
  if (response->code != RESP_CODE_ERR)
    response->body = g_strdup (http_scanner_stream_str (conn));
  else
    {
      response->body = g_strdup (
        "{\"error\": \"Not possible to get performance information.\"}");
      g_warning ("%s: Not possible to get performance information", __func__);
    }
 
  http_scanner_reset_stream (conn);
  return response;
}

int
openvasd_parsed_performance (http_scanner_connector_t conn,
                             openvasd_get_performance_opts_t opts,
                             gchar **graph, gchar **err)
{
  http_scanner_resp_t resp = NULL;
  cJSON *parser;
  cJSON *item;
  int ret = 0;
  resp = openvasd_get_performance (conn, opts);
 
  // No results. No information.
  parser = cJSON_Parse (resp->body);
  if (parser == NULL)
    {
      *err = g_strdup ("Unable to parse sensor performance data");
      ret = -1;
    }
  else if (resp->code != 200)
    {
      parser = cJSON_Parse (resp->body);
      item = cJSON_GetObjectItem (parser, "error");
      if (item != NULL)
        *err = g_strdup (cJSON_GetStringValue (item));
      ret = -1;
    }
  else
    {
      item = cJSON_GetArrayItem (parser, 0);
      if (item != NULL)
        *graph = g_strdup (cJSON_GetStringValue (item));
    }
 
  http_scanner_response_cleanup (resp);
  cJSON_Delete (parser);
 
  return ret;
}
 
// Scan config builder.

static void
add_port_to_scan_json (gpointer range, gpointer p_array)
{
  range_t *ports = range;
 
  cJSON *port = cJSON_CreateObject ();
  if (ports->type == 1)
    cJSON_AddStringToObject (port, "protocol", "udp");
  else
    cJSON_AddStringToObject (port, "protocol", "tcp");
 
  cJSON *ranges_array = cJSON_CreateArray ();
  cJSON *range_obj = cJSON_CreateObject ();
  cJSON_AddNumberToObject (range_obj, "start", ports->start);
 
  if (ports->end > ports->start && ports->end < 65535)
    cJSON_AddNumberToObject (range_obj, "end", ports->end);
  else
    cJSON_AddNumberToObject (range_obj, "end", ports->start);
  cJSON_AddItemToArray (ranges_array, range_obj);
  cJSON_AddItemToObject (port, "range", ranges_array);
  cJSON_AddItemToArray ((cJSON *) p_array, port);
}

static void
add_auth_data_key_value_as_json (const char *key, const char *value,
                                 void *json_obj)
{
  if (!key || !value || !json_obj)
    return;
  cJSON_AddStringToObject ((cJSON *) json_obj, key, value);
}

static void
add_credential_to_scan_json (gpointer credentials, gpointer cred_array)
{
  cJSON *cred_obj = NULL;
 
  scan_credential_t *cred = credentials;
 
  const gchar *type = scan_credential_get_type (cred);
  const gchar *service = scan_credential_get_service (cred);
  const gchar *port = scan_credential_get_port (cred);
 
  cred_obj = cJSON_CreateObject ();
  cJSON_AddStringToObject (cred_obj, "service", service ? service : "");
 
  if (port)
    {
      cJSON_AddNumberToObject (cred_obj, "port", atoi (port));
    }
 
  cJSON *cred_type_obj = cJSON_CreateObject ();
  scan_credential_foreach_auth_data (cred, add_auth_data_key_value_as_json,
                                     cred_type_obj);
  cJSON_AddItemToObject (cred_obj, type ? type : "", cred_type_obj);
 
  cJSON_AddItemToArray ((cJSON *) cred_array, cred_obj);
}

static void
add_scan_preferences_to_scan_json (gpointer key, gpointer val,
                                   gpointer scan_prefs_array)
{
  cJSON *pref_obj = cJSON_CreateObject ();
  cJSON_AddStringToObject (pref_obj, "id", key);
  cJSON_AddStringToObject (pref_obj, "value", val);
  cJSON_AddItemToArray (scan_prefs_array, pref_obj);
}

static void
add_vts_to_scan_json (gpointer single_vt, gpointer vts_array)
{
  GHashTableIter vt_data_iter;
  gchar *vt_param_id, *vt_param_value;
 
  openvasd_vt_single_t *vt = single_vt;
 
  cJSON *vt_obj = cJSON_CreateObject ();
 
  cJSON_AddStringToObject (vt_obj, "oid", vt->vt_id);
 
  if (g_hash_table_size (vt->vt_values))
    {
      cJSON *params_array = cJSON_CreateArray ();
 
      g_hash_table_iter_init (&vt_data_iter, vt->vt_values);
      while (g_hash_table_iter_next (&vt_data_iter, (gpointer *) &vt_param_id,
                                     (gpointer *) &vt_param_value))
        {
          cJSON *param_obj = cJSON_CreateObject ();
          cJSON_AddNumberToObject (param_obj, "id", atoi (vt_param_id));
          cJSON_AddStringToObject (param_obj, "value", vt_param_value);
          cJSON_AddItemToArray (params_array, param_obj);
        }
      cJSON_AddItemToObject (vt_obj, "parameters", params_array);
    }
  cJSON_AddItemToArray (vts_array, vt_obj);
}

char *
openvasd_build_scan_config_json (openvasd_target_t *target,
                                 GHashTable *scan_preferences, GSList *vts)
{
  cJSON *scan_obj = NULL;
  cJSON *target_obj = NULL;
  cJSON *hosts_array = NULL;
  cJSON *exclude_hosts_array = NULL;
  cJSON *finished_hosts_array = NULL;
  gchar *json_str = NULL;
 
  /* Build the message in json format to be published. */
  scan_obj = cJSON_CreateObject ();
 
  if (target->scan_id && target->scan_id[0] != '\0')
    cJSON_AddStringToObject (scan_obj, "scan_id", target->scan_id);
 
  // begin target
  target_obj = cJSON_CreateObject ();
 
  // hosts
  hosts_array = cJSON_CreateArray ();
  gchar **hosts_list = g_strsplit (target->hosts, ",", 0);
  for (int i = 0; hosts_list[i] != NULL; i++)
    {
      cJSON *host_item = NULL;
      host_item = cJSON_CreateString (hosts_list[i]);
      cJSON_AddItemToArray (hosts_array, host_item);
    }
  g_strfreev (hosts_list);
  cJSON_AddItemToObject (target_obj, "hosts", hosts_array);
 
  // exclude hosts
  if (target->exclude_hosts && target->exclude_hosts[0] != '\0')
    {
      exclude_hosts_array = cJSON_CreateArray ();
      gchar **exclude_hosts_list = g_strsplit (target->exclude_hosts, ",", 0);
      for (int i = 0; exclude_hosts_list[i] != NULL; i++)
        {
          cJSON *exclude_host_item = NULL;
          exclude_host_item = cJSON_CreateString (exclude_hosts_list[i]);
          cJSON_AddItemToArray (exclude_hosts_array, exclude_host_item);
        }
      g_strfreev (exclude_hosts_list);
      cJSON_AddItemToObject (target_obj, "excluded_hosts", exclude_hosts_array);
    }
 
  // finished hosts
  if (target->finished_hosts && target->finished_hosts[0] != '\0')
    {
      finished_hosts_array = cJSON_CreateArray ();
      gchar **finished_hosts_list = g_strsplit (target->finished_hosts, ",", 0);
      for (int i = 0; finished_hosts_list[i] != NULL; i++)
        {
          cJSON *finished_host_item = NULL;
          finished_host_item = cJSON_CreateString (finished_hosts_list[i]);
          cJSON_AddItemToArray (finished_hosts_array, finished_host_item);
        }
      g_strfreev (hosts_list);
      cJSON_AddItemToObject (target_obj, "finished_hosts",
                             finished_hosts_array);
    }
 
  // ports
  if (target->ports && target->ports[0] != '\0')
    {
      cJSON *ports_array = cJSON_CreateArray ();
      array_t *ports = port_range_ranges (target->ports);
      g_ptr_array_foreach (ports, add_port_to_scan_json, ports_array);
      array_free (ports);
      cJSON_AddItemToObject (target_obj, "ports", ports_array);
    }
 
  // credentials
  cJSON *credentials = cJSON_CreateArray ();
  g_slist_foreach (target->credentials, add_credential_to_scan_json,
                   credentials);
  cJSON_AddItemToObject (target_obj, "credentials", credentials);
 
  // reverse lookup
  if (target->reverse_lookup_unify)
    cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", 1);
  else
    cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", 0);
 
  if (target->reverse_lookup_only)
    cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", 1);
  else
    cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", 0);
 
  // alive test methods
  cJSON *alive_test_methods = cJSON_CreateArray ();
  if (target->alive_test_methods.arp)
    cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("arp"));
  if (target->alive_test_methods.tcp_ack)
    cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_ack"));
  if (target->alive_test_methods.tcp_syn)
    cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_syn"));
  if (target->alive_test_methods.consider_alive)
    cJSON_AddItemToArray (alive_test_methods,
                          cJSON_CreateString ("consider_alive"));
  if (target->alive_test_methods.icmp)
    cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("icmp"));
  if (target->alive_test_methods.host_discovery_ipv6)
    cJSON_AddItemToArray (alive_test_methods,
                          cJSON_CreateString ("host_discovery_ipv6"));
 
  cJSON_AddItemToObject (target_obj, "alive_test_methods", alive_test_methods);
 
  cJSON_AddItemToObject (scan_obj, "target", target_obj);
 
  // Begin Scan Preferences
  cJSON *scan_prefs_array = cJSON_CreateArray ();
  g_hash_table_foreach (scan_preferences, add_scan_preferences_to_scan_json,
                        scan_prefs_array);
  cJSON_AddItemToObject (scan_obj, "scan_preferences", scan_prefs_array);
 
  // Begin VTs
  cJSON *vts_array = cJSON_CreateArray ();
  g_slist_foreach (vts, add_vts_to_scan_json, vts_array);
  cJSON_AddItemToObject (scan_obj, "vts", vts_array);
 
  json_str = cJSON_Print (scan_obj);
  cJSON_Delete (scan_obj);
  if (json_str == NULL)
    g_warning ("%s: Error while creating JSON.", __func__);
 
  return json_str;
}

openvasd_target_t *
openvasd_target_new (const gchar *scanid, const gchar *hosts,
                     const gchar *ports, const gchar *exclude_hosts,
                     int reverse_lookup_unify, int reverse_lookup_only)
{
  openvasd_target_t *new_target;
  new_target = g_malloc0 (sizeof (openvasd_target_t));
 
  if (scanid && *scanid)
    new_target->scan_id = g_strdup (scanid);
 
  new_target->exclude_hosts = exclude_hosts ? g_strdup (exclude_hosts) : NULL;
  new_target->finished_hosts = NULL;
  new_target->hosts = hosts ? g_strdup (hosts) : NULL;
  new_target->ports = ports ? g_strdup (ports) : NULL;
  new_target->reverse_lookup_unify =
    reverse_lookup_unify ? reverse_lookup_unify : 0;
  new_target->reverse_lookup_only =
    reverse_lookup_only ? reverse_lookup_only : 0;
 
  return new_target;
}

void
openvasd_target_set_finished_hosts (openvasd_target_t *target,
                                    const gchar *finished_hosts)
{
  g_free (target->finished_hosts);
  target->finished_hosts = finished_hosts ? g_strdup (finished_hosts) : NULL;
}

void
openvasd_target_free (openvasd_target_t *target)
{
  if (!target)
    return;
 
  g_slist_free_full (target->credentials,
                     (GDestroyNotify) scan_credential_free);
  g_free (target->exclude_hosts);
  g_free (target->finished_hosts);
  g_free (target->scan_id);
  g_free (target->hosts);
  g_free (target->ports);
  g_free (target);
  target = NULL;
}

void
openvasd_target_set_alive_test_methods (
  openvasd_target_t *target, const openvasd_alive_test_methods_t *methods)
{
  if (!target || !methods)
    return;
 
  if (methods->host_discovery_ipv6)
    {
      target->alive_test_methods =
        (openvasd_alive_test_methods_t){.host_discovery_ipv6 = TRUE};
      return;
    }
 
  target->alive_test_methods = *methods;
}

void
openvasd_target_add_credential (openvasd_target_t *target,
                                scan_credential_t *credential)
{
  if (!target || !credential)
    return;
 
  target->credentials = g_slist_prepend (target->credentials, credential);
}

openvasd_vt_single_t *
openvasd_vt_single_new (const gchar *vt_id)
{
  openvasd_vt_single_t *new_vt_single;
  new_vt_single = g_malloc0 (sizeof (openvasd_vt_single_t));
 
  new_vt_single->vt_id = vt_id ? g_strdup (vt_id) : NULL;
  new_vt_single->vt_values =
    g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
 
  return new_vt_single;
}

void
openvasd_vt_single_free (openvasd_vt_single_t *vt_single)
{
  if (!vt_single)
    return;
 
  g_hash_table_destroy (vt_single->vt_values);
 
  g_free (vt_single->vt_id);
  g_free (vt_single);
}

void
openvasd_vt_single_add_value (openvasd_vt_single_t *vt_single,
                              const gchar *name, const gchar *value)
{
  g_hash_table_replace (vt_single->vt_values, g_strdup (name),
                        g_strdup (value));
}