17#include <cjson/cJSON.h>
20#include <curl/multi.h>
21#include <netinet/in.h>
31#define G_LOG_DOMAIN "libgvm ovd"
33#define RESP_CODE_ERR -1
161 CURLMsg *msg = curl_multi_info_read (h->
h, &queued);
164 if (msg->msg == CURLMSG_DONE)
166 curl_multi_remove_handle (h->
h, msg->easy_handle);
167 curl_easy_cleanup (msg->easy_handle);
169 curl_multi_cleanup (h->
h);
172 g_warning (
"%s: Not possible to clean up the curl handler", __func__);
187 s->
ptr = g_malloc0 (s->
len + 1);
221 s->
ptr = g_malloc0 (s->
len + 1);
269 conn->
ca_cert = g_strdup ((
char *) val);
272 conn->
cert = g_strdup ((
char *) val);
275 conn->
key = g_strdup ((
char *) val);
278 conn->
apikey = g_strdup ((
char *) val);
281 conn->
server = g_strdup ((
char *) val);
284 conn->
host = g_strdup ((
char *) val);
287 conn->
scan_id = g_strdup ((
const gchar *) val);
291 conn->
port = *((
int *) val);
352 size_t new_len = s->
len + size * nmemb;
353 gchar *ptr_aux = g_realloc (s->
ptr, new_len + 1);
355 memcpy (s->
ptr + s->
len, ptr, size * nmemb);
356 s->
ptr[new_len] =
'\0';
362static struct curl_slist *
365 struct curl_slist *customheader = NULL;
366 struct curl_slist *temp = NULL;
372 xapikey = g_string_new (
"X-API-KEY: ");
373 g_string_append (xapikey, apikey);
374 temp = curl_slist_append (customheader, xapikey->str);
376 g_warning (
"%s: Not possible to set API-KEY", __func__);
379 g_string_free (xapikey, TRUE);
384 temp = curl_slist_append (customheader,
"Content-Type: application/json");
386 g_warning (
"%s: Not possible to set Content-Type", __func__);
412 gchar *data,
struct curl_slist *customheader, gchar **err)
419 *err = g_strdup (
"{\"error\": \"Missing openvasd connector\"}");
420 g_warning (
"%s: Missing openvasd connector", __func__);
424 if ((curl = curl_easy_init ()) == NULL)
427 g_strdup (
"{\"error\": \"Not possible to initialize curl library\"}");
428 g_warning (
"%s: Not possible to initialize curl library", __func__);
432 url = g_string_new (g_strdup (conn->
server));
434 if (conn->
port > 0 && conn->
port < 65535)
437 g_snprintf (buf,
sizeof (buf),
":%d", conn->
port);
438 g_string_append (url, buf);
441 if (path != NULL && path[0] !=
'\0')
442 g_string_append (url, path);
445 g_debug (
"%s: URL: %s", __func__, url->str);
446 if (curl_easy_setopt (curl, CURLOPT_URL, url->str) != CURLE_OK)
448 g_string_free (url, TRUE);
449 g_warning (
"%s: Not possible to set the URL", __func__);
450 curl_easy_cleanup (curl);
451 *err = g_strdup (
"{\"error\": \"Not possible to set URL\"}");
454 g_string_free (url, TRUE);
459 struct curl_blob blob;
461 blob.len = strlen (conn->
ca_cert);
462 blob.flags = CURL_BLOB_COPY;
464 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 1L);
465 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 1L);
466 if (curl_easy_setopt (curl, CURLOPT_CAINFO_BLOB, &blob) != CURLE_OK)
468 g_warning (
"%s: Not possible to set the CA certificate", __func__);
469 curl_easy_cleanup (curl);
471 g_strdup (
"{\"error\": \"Not possible to set CA certificate\"}");
478 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 0L);
479 curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 0L);
480 curl_easy_setopt (curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2);
481 g_debug (
"%s: Server certificate verification disabled.", __func__);
485 if (conn->
cert != NULL && conn->
key != NULL)
487 struct curl_blob blob;
488 blob.data = conn->
cert;
489 blob.len = strlen (conn->
cert);
490 blob.flags = CURL_BLOB_COPY;
492 if (curl_easy_setopt (curl, CURLOPT_SSLCERT_BLOB, &blob) != CURLE_OK)
494 g_warning (
"%s: Not possible to set the Client certificate",
496 curl_easy_cleanup (curl);
498 "{\"error\": \"Not possible to set Client certificate\"}");
501 blob.data = conn->
key;
502 blob.len = strlen (conn->
key);
503 blob.flags = CURL_BLOB_COPY;
505 if (curl_easy_setopt (curl, CURLOPT_SSLKEY_BLOB, &blob) != CURLE_OK)
507 g_warning (
"%s: Not possible to set the Client private key",
509 curl_easy_cleanup (curl);
511 "{\"error\": \"Not possible to set Client private key\"}");
519 if (data != NULL && data[0] !=
'\0')
522 curl_easy_setopt (curl, CURLOPT_POSTFIELDS, data);
523 curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen (data));
527 curl_easy_setopt (curl, CURLOPT_HTTPGET, 1L);
530 curl_easy_setopt (curl, CURLOPT_CUSTOMREQUEST,
"DELETE");
533 curl_easy_setopt (curl, CURLOPT_CUSTOMREQUEST,
"HEAD");
537 if (customheader != NULL)
538 curl_easy_setopt (curl, CURLOPT_HTTPHEADER, customheader);
542 curl_easy_setopt (curl, CURLOPT_WRITEDATA, conn->
stream_resp);
567 if ((ret = curl_easy_perform (curl)) != CURLE_OK)
569 g_warning (
"%s: Error sending request: %d", __func__, ret);
570 curl_easy_cleanup (curl);
571 response->
code = http_code;
572 response->
body = g_strdup (
"{\"error\": \"Error sending request\"}");
576 curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &http_code);
579 struct curl_header *hname;
580 curl_easy_header (curl, header_name, 0, CURLH_HEADER, -1, &hname);
581 response->
header = g_strdup (hname->value);
583 curl_easy_cleanup (curl);
584 response->
code = http_code;
602 struct curl_slist *customheader = NULL;
607 hnd =
handler (conn,
HEAD,
"/", NULL, customheader, &err);
610 curl_slist_free_all (customheader);
612 response->
body = err;
618 curl_slist_free_all (customheader);
646 struct curl_slist *customheader = NULL;
650 path = g_string_new (
"/vts?information=1");
652 hnd =
handler (conn,
GET, path->str, NULL, customheader, &err);
655 curl_slist_free_all (customheader);
656 g_string_free (path, TRUE);
658 response->
body = err;
661 g_string_free (path, TRUE);
663 h = curl_multi_init ();
664 curl_multi_add_handle (h, hnd);
705 static int running = 0;
712 CURLMcode mc = curl_multi_perform (h, &running);
715 mc = curl_multi_poll (h, NULL, 0, 5000, NULL);
718 g_warning (
"%s: error on curl_multi_poll(): %d\n", __func__, mc);
740 struct curl_slist *customheader = NULL;
744 path = g_string_new (
"/vts?information=1");
746 hnd =
handler (conn,
GET, path->str, NULL, customheader, &err);
749 curl_slist_free_all (customheader);
750 g_string_free (path, TRUE);
752 response->
body = err;
755 g_string_free (path, TRUE);
758 curl_slist_free_all (customheader);
778 cJSON *parser = NULL;
782 struct curl_slist *customheader = NULL;
787 hnd =
handler (conn,
POST,
"/scans", data, customheader, &err);
790 curl_slist_free_all (customheader);
792 response->
body = err;
797 curl_slist_free_all (customheader);
801 if (response->
body == NULL)
803 g_strdup (
"{\"error\": \"Storing scan configuration\"}");
804 g_warning (
"%s: Error storing scan configuration ", __func__);
813 const gchar *error_ptr = cJSON_GetErrorPtr ();
814 g_warning (
"%s: Error parsing json string to get the scan ID", __func__);
815 if (error_ptr != NULL)
817 response->
body = g_strdup_printf (
"{\"error\": \"%s\"}", error_ptr);
818 g_warning (
"%s: %s", __func__, error_ptr);
822 response->
body = g_strdup (
823 "{\"error\": \"Parsing json string to get the scan ID\"}");
826 cJSON_Delete (parser);
831 conn->
scan_id = g_strdup (cJSON_GetStringValue (parser));
834 path = g_string_new (
"/scans");
837 g_string_append (path,
"/");
838 g_string_append (path, conn->
scan_id);
843 response->
body = g_strdup (
"{\"error\": \"Missing scan ID\"}");
844 g_string_free (path, TRUE);
845 g_warning (
"%s: Missing scan ID", __func__);
846 cJSON_Delete (parser);
852 hnd =
handler (conn,
POST, path->str,
"{\"action\": \"start\"}", customheader,
856 curl_slist_free_all (customheader);
857 g_string_free (path, TRUE);
859 response->
body = err;
862 g_string_free (path, TRUE);
865 curl_slist_free_all (customheader);
869 if (response->
body == NULL)
870 response->
body = g_strdup (
"{\"error\": \"Starting the scan.\"}");
871 g_warning (
"%s: Error starting the scan.", __func__);
875 cJSON_Delete (parser);
888 struct curl_slist *customheader = NULL;
893 path = g_string_new (
"/scans");
896 g_string_append (path,
"/");
897 g_string_append (path, conn->
scan_id);
902 response->
body = g_strdup (
"{\"error\": \"Missing scan ID\"}");
903 g_string_free (path, TRUE);
904 g_warning (
"%s: Missing scan ID", __func__);
909 hnd =
handler (conn,
POST, path->str,
"{\"action\": \"stop\"}", customheader,
913 curl_slist_free_all (customheader);
914 g_string_free (path, TRUE);
916 response->
body = err;
919 g_string_free (path, TRUE);
922 curl_slist_free_all (customheader);
934 GString *path = NULL;
937 struct curl_slist *customheader = NULL;
941 path = g_string_new (
"/scans");
944 g_string_append (path,
"/");
945 g_string_append (path, conn->
scan_id);
947 g_string_append_printf (path,
"/results?range%ld-%ld", first, last);
948 else if (last < first)
949 g_string_append_printf (path,
"/results?range=%ld", first);
951 g_string_append (path,
"/results");
956 response->
body = g_strdup (
"{\"error\": \"Missing scan ID\"}");
957 g_string_free (path, TRUE);
958 g_warning (
"%s: Missing scan ID", __func__);
963 hnd =
handler (conn,
GET, path->str, NULL, customheader, &err);
966 curl_slist_free_all (customheader);
967 g_string_free (path, TRUE);
969 response->
body = err;
972 g_string_free (path, TRUE);
975 curl_slist_free_all (customheader);
980 g_warning (
"%s: Not possible to get scan results", __func__);
982 g_strdup (
"{\"error\": \"Not possible to get scan results\"}");
991 gchar *hostname, gchar *oid,
int port, gchar *protocol,
992 gchar *message, gchar *detail_name, gchar *detail_value,
993 gchar *detail_source_type, gchar *detail_source_name,
994 gchar *detail_source_description)
999 result->
type = g_strdup (type);
1001 result->
hostname = g_strdup (hostname);
1002 result->
oid = g_strdup (oid);
1003 result->
port = port;
1004 result->
protocol = g_strdup (protocol);
1005 result->
message = g_strdup (message);
1024 return result->
type;
1063 return result->
port;
1075 g_free (result->
type);
1078 g_free (result->
oid);
1093 cJSON *parser = NULL;
1094 cJSON *result_obj = NULL;
1095 const gchar *err = NULL;
1098 gchar *detail_name = NULL;
1099 gchar *detail_value = NULL;
1100 gchar *detail_source_type = NULL;
1101 gchar *detail_source_name = NULL;
1102 gchar *detail_source_description = NULL;
1105 if ((parser = cJSON_Parse (body)) == NULL)
1107 err = cJSON_GetErrorPtr ();
1110 if (!cJSON_IsArray (parser))
1116 cJSON_ArrayForEach (result_obj, parser)
1119 if (!cJSON_IsObject (result_obj))
1123 if ((item = cJSON_GetObjectItem (result_obj,
"port")) != NULL
1124 && cJSON_IsNumber (item))
1125 port = item->valueint;
1127 if ((item = cJSON_GetObjectItem (result_obj,
"detail")) != NULL
1128 && cJSON_IsObject (item))
1130 cJSON *detail_obj = NULL;
1132 if ((detail_obj = cJSON_GetObjectItem (item,
"name")) != NULL
1133 && cJSON_IsString (detail_obj))
1134 detail_name = g_strdup (detail_obj->valuestring);
1136 if ((detail_obj = cJSON_GetObjectItem (item,
"value")) != NULL
1137 && cJSON_IsString (detail_obj))
1138 detail_value = g_strdup (detail_obj->valuestring);
1140 detail_obj = cJSON_GetObjectItem (item,
"source");
1141 if (detail_obj && cJSON_IsObject (detail_obj))
1145 if ((source_obj = cJSON_GetObjectItem (detail_obj,
"type")) != NULL
1146 && cJSON_IsString (source_obj))
1147 detail_source_type = g_strdup (source_obj->valuestring);
1149 if ((source_obj = cJSON_GetObjectItem (detail_obj,
"name")) != NULL
1150 && cJSON_IsString (source_obj))
1151 detail_source_name = g_strdup (source_obj->valuestring);
1153 if ((source_obj = cJSON_GetObjectItem (detail_obj,
"description"))
1155 && cJSON_IsString (source_obj))
1156 detail_source_description = g_strdup (source_obj->valuestring);
1168 detail_name, detail_value,
1169 detail_source_type, detail_source_name,
1170 detail_source_description);
1172 *results = g_slist_append (*results, result);
1179 g_warning (
"%s: Unable to parse scan results. Reason: %s", __func__, err);
1181 cJSON_Delete (parser);
1188 unsigned long last, GSList **results)
1194 if (resp->
code == 200)
1208 GString *path = NULL;
1211 struct curl_slist *customheader = NULL;
1215 path = g_string_new (
"/scans");
1218 g_string_append (path,
"/");
1219 g_string_append (path, conn->
scan_id);
1220 g_string_append (path,
"/status");
1225 response->
body = g_strdup (
"{\"error\": \"Missing scan ID\"}");
1226 g_string_free (path, TRUE);
1227 g_warning (
"%s: Missing scan ID", __func__);
1232 hnd =
handler (conn,
GET, path->str, NULL, customheader, &err);
1235 curl_slist_free_all (customheader);
1236 g_string_free (path, TRUE);
1238 response->
body = err;
1241 g_string_free (path, TRUE);
1244 curl_slist_free_all (customheader);
1250 g_strdup (
"{\"error\": \"Not possible to get scan status\"}");
1251 g_warning (
"%s: Not possible to get scan status", __func__);
1266 if ((item = cJSON_GetObjectItem (reader, member)) == NULL
1267 && cJSON_IsNumber (item))
1270 return item->valueint;
1278 cJSON *reader = NULL;
1279 const gchar *err = NULL;
1280 int all = 0, excluded = 0, dead = 0, alive = 0, queued = 0, finished = 0;
1281 int running_hosts_progress_sum = 0;
1286 if (!response && !conn)
1289 if (response == NULL)
1294 if (resp->
code == 404)
1296 else if (resp->
code != 200)
1299 parser = cJSON_Parse (resp->
body);
1302 err = cJSON_GetErrorPtr ();
1306 if ((reader = cJSON_GetObjectItem (parser,
"host_info")) == NULL)
1310 if (!cJSON_IsObject (reader))
1326 cJSON *scanning = NULL;
1327 if ((scanning = cJSON_GetObjectItem (reader,
"scanning")) != NULL
1328 && cJSON_IsObject (scanning))
1330 cJSON *host = scanning->child;
1333 running_hosts_progress_sum += cJSON_GetNumberValue (host);
1340 if (all < 0 || excluded < 0 || dead < 0 || alive < 0 || queued < 0
1346 if ((all + finished - dead) > 0)
1347 progress = (running_hosts_progress_sum + 100 * (alive + finished))
1348 / (all + finished - dead);
1354 g_warning (
"%s: Unable to parse scan status. Reason: %s", __func__, err);
1355 cJSON_Delete (parser);
1371 if (g_strcmp0 (status_val,
"stored") == 0)
1373 else if (g_strcmp0 (status_val,
"requested") == 0)
1375 else if (g_strcmp0 (status_val,
"running") == 0)
1377 else if (g_strcmp0 (status_val,
"stopped") == 0)
1379 else if (g_strcmp0 (status_val,
"succeeded") == 0)
1381 else if (g_strcmp0 (status_val,
"interrupted") == 0)
1390 cJSON *parser = NULL;
1391 cJSON *status = NULL;
1392 gchar *status_val = NULL;
1398 if ((parser = cJSON_Parse (body)) == NULL)
1401 if ((status = cJSON_GetObjectItem (parser,
"status")) == NULL
1402 || !cJSON_IsString (status))
1404 cJSON_Delete (parser);
1408 status_val = g_strdup (status->valuestring);
1410 g_free (status_val);
1412 status_info->
status = status_code;
1415 cJSON_Delete (parser);
1440 status_info->
status = status_code;
1460 struct curl_slist *customheader = NULL;
1465 path = g_string_new (
"/scans");
1468 g_string_append (path,
"/");
1469 g_string_append (path, conn->
scan_id);
1474 response->
body = g_strdup (
"{\"error\": \"Missing scan ID\"}");
1475 g_string_free (path, TRUE);
1476 g_warning (
"%s: Missing scan ID", __func__);
1481 hnd =
handler (conn,
DELETE, path->str, NULL, customheader, &err);
1484 curl_slist_free_all (customheader);
1485 g_string_free (path, TRUE);
1487 response->
body = err;
1490 g_string_free (path, TRUE);
1493 curl_slist_free_all (customheader);
1499 g_strdup (
"{\"error\": \"Not possible to delete scan.\"}");
1500 g_warning (
"%s: Not possible to delete scan", __func__);
1513 struct curl_slist *customheader = NULL;
1518 hnd =
handler (conn,
GET,
"/health/alive", NULL, customheader, &err);
1521 curl_slist_free_all (customheader);
1523 response->
body = err;
1528 curl_slist_free_all (customheader);
1534 g_strdup (
"{\"error\": \"Not possible to get health information.\"}");
1535 g_warning (
"%s: Not possible to get health information", __func__);
1548 struct curl_slist *customheader = NULL;
1553 hnd =
handler (conn,
GET,
"/health/ready", NULL, customheader, &err);
1557 response->
body = err;
1562 curl_slist_free_all (customheader);
1568 g_strdup (
"{\"error\": \"Not possible to get health information.\"}");
1569 g_warning (
"%s: Not possible to get health information", __func__);
1582 struct curl_slist *customheader = NULL;
1587 hnd =
handler (conn,
GET,
"/health/started", NULL, customheader, &err);
1590 curl_slist_free_all (customheader);
1592 response->
body = err;
1597 curl_slist_free_all (customheader);
1603 g_strdup (
"{\"error\": \"Not possible to get health information.\"}");
1604 g_warning (
"%s: Not possible to get health information", __func__);
1617 struct curl_slist *customheader = NULL;
1623 handler (conn,
GET,
"/scans/preferences", NULL, customheader, &err))
1626 curl_slist_free_all (customheader);
1628 response->
body = err;
1633 curl_slist_free_all (customheader);
1639 g_strdup (
"{\"error\": \"Not possible to get scans preferences.\"}");
1640 g_warning (
"%s: Not possible to get scans_preferences", __func__);
1654 gchar *type,
int mandatory)
1678 g_free (param->
name);
1681 g_free (param->
type);
1773 cJSON *param_obj = NULL;
1778 if (resp->
code != 200)
1782 if ((parser = cJSON_Parse (resp->
body)) == NULL || !cJSON_IsArray (parser))
1788 cJSON_ArrayForEach (param_obj, parser)
1790 gchar *defval = NULL, *param_type = NULL;
1792 int val, mandatory = 0;
1796 if ((item = cJSON_GetObjectItem (param_obj,
"default")) != NULL)
1798 if (cJSON_IsNumber (item))
1800 val = item->valueint;
1801 g_snprintf (buf,
sizeof (buf),
"%d", val);
1802 defval = g_strdup (buf);
1803 param_type = g_strdup (
"integer");
1805 else if (cJSON_IsString (item))
1807 defval = g_strdup (item->valuestring);
1808 param_type = g_strdup (
"string");
1810 else if (cJSON_IsBool (item))
1812 if (cJSON_IsTrue (item))
1813 defval = g_strdup (
"yes");
1815 defval = g_strdup (
"no");
1816 param_type = g_strdup (
"boolean");
1820 g_warning (
"%s: Unable to parse scan preferences.", __func__);
1822 g_free (param_type);
1832 g_strdup (param_type), mandatory);
1834 g_free (param_type);
1835 *params = g_slist_append (*params, param);
1840 cJSON_Delete (parser);
1843 g_warning (
"%s: Unable to parse scan preferences.", __func__);
1856 cJSON *port = cJSON_CreateObject ();
1857 if (ports->
type == 1)
1858 cJSON_AddStringToObject (port,
"protocol",
"udp");
1860 cJSON_AddStringToObject (port,
"protocol",
"tcp");
1862 cJSON *ranges_array = cJSON_CreateArray ();
1863 cJSON *range_obj = cJSON_CreateObject ();
1864 cJSON_AddNumberToObject (range_obj,
"start", ports->
start);
1866 if (ports->
end > ports->
start && ports->
end < 65535)
1867 cJSON_AddNumberToObject (range_obj,
"end", ports->
end);
1869 cJSON_AddNumberToObject (range_obj,
"end", ports->
start);
1870 cJSON_AddItemToArray (ranges_array, range_obj);
1871 cJSON_AddItemToObject (port,
"range", ranges_array);
1872 cJSON_AddItemToArray ((cJSON *) p_array, port);
1878 GHashTableIter auth_data_iter;
1879 gchar *auth_data_name, *auth_data_value;
1880 cJSON *cred_obj = NULL;
1884 cred_obj = cJSON_CreateObject ();
1885 cJSON_AddStringToObject (cred_obj,
"service", cred->
service);
1889 cJSON_AddNumberToObject (cred_obj,
"port", atoi (cred->
port));
1892 cJSON *cred_type_obj = cJSON_CreateObject ();
1893 g_hash_table_iter_init (&auth_data_iter, cred->
auth_data);
1894 while (g_hash_table_iter_next (&auth_data_iter, (gpointer *) &auth_data_name,
1895 (gpointer *) &auth_data_value))
1896 cJSON_AddStringToObject (cred_type_obj, auth_data_name, auth_data_value);
1897 cJSON_AddItemToObject (cred_obj, cred->
type, cred_type_obj);
1899 cJSON_AddItemToArray ((cJSON *) cred_array, cred_obj);
1904 gpointer scan_prefs_array)
1906 cJSON *pref_obj = cJSON_CreateObject ();
1907 cJSON_AddStringToObject (pref_obj,
"id", key);
1908 cJSON_AddStringToObject (pref_obj,
"value", val);
1909 cJSON_AddItemToArray (scan_prefs_array, pref_obj);
1915 GHashTableIter vt_data_iter;
1916 gchar *vt_param_id, *vt_param_value;
1920 cJSON *vt_obj = cJSON_CreateObject ();
1922 cJSON_AddStringToObject (vt_obj,
"oid", vt->
vt_id);
1926 cJSON *params_array = cJSON_CreateArray ();
1928 g_hash_table_iter_init (&vt_data_iter, vt->
vt_values);
1929 while (g_hash_table_iter_next (&vt_data_iter, (gpointer *) &vt_param_id,
1930 (gpointer *) &vt_param_value))
1932 cJSON *param_obj = cJSON_CreateObject ();
1933 cJSON_AddNumberToObject (param_obj,
"id", atoi (vt_param_id));
1934 cJSON_AddStringToObject (param_obj,
"value", vt_param_value);
1935 cJSON_AddItemToArray (params_array, param_obj);
1937 cJSON_AddItemToObject (vt_obj,
"parameters", params_array);
1939 cJSON_AddItemToArray (vts_array, vt_obj);
1956 GHashTable *scan_preferences, GSList *vts)
1958 cJSON *scan_obj = NULL;
1959 cJSON *target_obj = NULL;
1960 cJSON *hosts_array = NULL;
1961 cJSON *exclude_hosts_array = NULL;
1962 cJSON *finished_hosts_array = NULL;
1963 gchar *json_str = NULL;
1966 scan_obj = cJSON_CreateObject ();
1969 cJSON_AddStringToObject (scan_obj,
"scan_id", target->
scan_id);
1972 target_obj = cJSON_CreateObject ();
1975 hosts_array = cJSON_CreateArray ();
1976 gchar **hosts_list = g_strsplit (target->
hosts,
",", 0);
1977 for (
int i = 0; hosts_list[i] != NULL; i++)
1979 cJSON *host_item = NULL;
1980 host_item = cJSON_CreateString (hosts_list[i]);
1981 cJSON_AddItemToArray (hosts_array, host_item);
1983 g_strfreev (hosts_list);
1984 cJSON_AddItemToObject (target_obj,
"hosts", hosts_array);
1989 exclude_hosts_array = cJSON_CreateArray ();
1990 gchar **exclude_hosts_list = g_strsplit (target->
exclude_hosts,
",", 0);
1991 for (
int i = 0; exclude_hosts_list[i] != NULL; i++)
1993 cJSON *exclude_host_item = NULL;
1994 exclude_host_item = cJSON_CreateString (exclude_hosts_list[i]);
1995 cJSON_AddItemToArray (exclude_hosts_array, exclude_host_item);
1997 g_strfreev (exclude_hosts_list);
1998 cJSON_AddItemToObject (target_obj,
"excluded_hosts", exclude_hosts_array);
2004 finished_hosts_array = cJSON_CreateArray ();
2005 gchar **finished_hosts_list = g_strsplit (target->
finished_hosts,
",", 0);
2006 for (
int i = 0; finished_hosts_list[i] != NULL; i++)
2008 cJSON *finished_host_item = NULL;
2009 finished_host_item = cJSON_CreateString (finished_hosts_list[i]);
2010 cJSON_AddItemToArray (finished_hosts_array, finished_host_item);
2012 g_strfreev (hosts_list);
2013 cJSON_AddItemToObject (target_obj,
"finished_hosts",
2014 finished_hosts_array);
2018 if (target->
ports && target->
ports[0] !=
'\0')
2020 cJSON *ports_array = cJSON_CreateArray ();
2024 cJSON_AddItemToObject (target_obj,
"ports", ports_array);
2028 cJSON *credentials = cJSON_CreateArray ();
2031 cJSON_AddItemToObject (target_obj,
"credentials", credentials);
2035 cJSON_AddBoolToObject (target_obj,
"reverse_lookup_unify", cJSON_True);
2037 cJSON_AddBoolToObject (target_obj,
"reverse_lookup_unify", cJSON_False);
2040 cJSON_AddBoolToObject (target_obj,
"reverse_lookup_only", cJSON_True);
2042 cJSON_AddBoolToObject (target_obj,
"reverse_lookup_only", cJSON_False);
2045 cJSON *alive_test_methods = cJSON_CreateArray ();
2047 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString (
"arp"));
2049 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString (
"tcp_ack"));
2051 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString (
"tcp_syn"));
2053 cJSON_AddItemToArray (alive_test_methods,
2054 cJSON_CreateString (
"consider_alive"));
2056 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString (
"icmp"));
2057 cJSON_AddItemToObject (target_obj,
"alive_test_methods", alive_test_methods);
2059 cJSON_AddItemToObject (scan_obj,
"target", target_obj);
2062 cJSON *scan_prefs_array = cJSON_CreateArray ();
2065 cJSON_AddItemToObject (scan_obj,
"scan_preferences", scan_prefs_array);
2068 cJSON *vts_array = cJSON_CreateArray ();
2070 cJSON_AddItemToObject (scan_obj,
"vts", vts_array);
2072 json_str = cJSON_Print (scan_obj);
2073 cJSON_Delete (scan_obj);
2074 if (json_str == NULL)
2075 g_warning (
"%s: Error while creating JSON.", __func__);
2097 new_credential->
type = type ? g_strdup (type) : NULL;
2098 new_credential->
service = service ? g_strdup (service) : NULL;
2099 new_credential->
port = port ? g_strdup (port) : NULL;
2101 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
2103 return new_credential;
2117 g_free (credential->
type);
2119 g_free (credential->
port);
2120 g_hash_table_destroy (credential->
auth_data);
2121 g_free (credential);
2133 const gchar *name,
const gchar *value)
2135 if (credential == NULL || name == NULL)
2138 if (g_regex_match_simple (
"^[[:alpha:]][[:alnum:]_]*$", name, 0, 0))
2141 g_hash_table_replace (credential->
auth_data, g_strdup (name),
2144 g_hash_table_remove (credential->
auth_data, name);
2148 g_warning (
"%s: Invalid auth data name: %s", __func__, name);
2166 const gchar *ports,
const gchar *exclude_hosts,
2167 int reverse_lookup_unify,
int reverse_lookup_only)
2172 if (scanid && *scanid)
2173 new_target->
scan_id = g_strdup (scanid);
2175 new_target->
exclude_hosts = exclude_hosts ? g_strdup (exclude_hosts) : NULL;
2177 new_target->
hosts = hosts ? g_strdup (hosts) : NULL;
2178 new_target->
ports = ports ? g_strdup (ports) : NULL;
2180 reverse_lookup_unify ? reverse_lookup_unify : 0;
2182 reverse_lookup_only ? reverse_lookup_only : 0;
2195 const gchar *finished_hosts)
2198 target->
finished_hosts = finished_hosts ? g_strdup (finished_hosts) : NULL;
2217 g_free (target->
hosts);
2218 g_free (target->
ports);
2235 gboolean icmp, gboolean tcp_syn,
2236 gboolean tcp_ack, gboolean arp,
2237 gboolean consider_alive)
2242 target->
icmp = icmp;
2259 if (!target || !credential)
2278 new_vt_single->
vt_id = vt_id ? g_strdup (vt_id) : NULL;
2280 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
2282 return new_vt_single;
2296 g_hash_table_destroy (vt_single->
vt_values);
2298 g_free (vt_single->
vt_id);
2313 const gchar *name,
const gchar *value)
2315 g_hash_table_replace (vt_single->
vt_values, g_strdup (name),
void array_free(GPtrArray *array)
Free global array value.
Definition array.c:50
GPtrArray array_t
Definition array.h:16
double gvm_json_obj_double(cJSON *obj, const gchar *key)
Get a double field from a JSON object.
Definition json.c:75
gchar * gvm_json_obj_str(cJSON *obj, const gchar *key)
Get a string field from a JSON object.
Definition json.c:95
array_t * port_range_ranges(const char *port_range)
Create a range array from a port_range string.
Definition networking.c:601
GVM Networking related API.
struct range range_t
Definition networking.h:43
void openvasd_target_add_credential(openvasd_target_t *target, openvasd_credential_t *credential)
Add a credential to an Openvasd target.
Definition openvasd.c:2256
void openvasd_param_free(openvasd_param_t *param)
Free an Openvasd parameter.
Definition openvasd.c:1673
static CURL * handler(openvasd_connector_t conn, openvasd_req_method_t method, gchar *path, gchar *data, struct curl_slist *customheader, gchar **err)
Create a CURL handler.
Definition openvasd.c:411
#define RESP_CODE_ERR
Definition openvasd.c:33
void openvasd_credential_set_auth_data(openvasd_credential_t *credential, const gchar *name, const gchar *value)
Get authentication data from an Openvasd credential.
Definition openvasd.c:2132
int openvasd_get_result_member_int(openvasd_result_t result, openvasd_result_member_int_t member)
Definition openvasd.c:1052
void openvasd_target_free(openvasd_target_t *target)
Free an Openvasd target, including all added credentials.
Definition openvasd.c:2207
openvasd_scan_status_t openvasd_parsed_scan_status(openvasd_connector_t conn)
Return a struct with the general scan status.
Definition openvasd.c:1428
char * openvasd_param_desc(openvasd_param_t *param)
Get the parameter description.
Definition openvasd.c:1718
openvasd_result_t openvasd_result_new(unsigned long id, gchar *type, gchar *ip_address, gchar *hostname, gchar *oid, int port, gchar *protocol, gchar *message, gchar *detail_name, gchar *detail_value, gchar *detail_source_type, gchar *detail_source_name, gchar *detail_source_description)
Definition openvasd.c:990
void openvasd_reset_vt_stream(openvasd_connector_t conn)
Definition openvasd.c:674
void openvasd_credential_free(openvasd_credential_t *credential)
Free an Openvasd credential.
Definition openvasd.c:2112
size_t openvasd_vt_stream_len(openvasd_connector_t conn)
Definition openvasd.c:686
openvasd_credential_t * openvasd_credential_new(const gchar *type, const gchar *service, const gchar *port)
Allocate and initialize a new Openvasd credential.
Definition openvasd.c:2090
openvasd_resp_t openvasd_get_scan_results(openvasd_connector_t conn, long first, long last)
Definition openvasd.c:931
char * openvasd_build_scan_config_json(openvasd_target_t *target, GHashTable *scan_preferences, GSList *vts)
Build a json object with data necessary to start a scan.
Definition openvasd.c:1955
char * openvasd_param_name(openvasd_param_t *param)
Get the parameter default.
Definition openvasd.c:1704
static void add_credential_to_scan_json(gpointer credentials, gpointer cred_array)
Definition openvasd.c:1876
openvasd_resp_t openvasd_get_scan_preferences(openvasd_connector_t conn)
Definition openvasd.c:1612
static void openvasd_curlm_handler_close(openvasd_curlm_t *h)
Cleanup an openvasd curl handler.
Definition openvasd.c:156
int openvasd_parsed_results(openvasd_connector_t conn, unsigned long first, unsigned long last, GSList **results)
Definition openvasd.c:1187
int openvasd_param_mandatory(openvasd_param_t *param)
If the parameter is mandatory.
Definition openvasd.c:1760
openvasd_resp_t openvasd_get_vt_stream_init(openvasd_connector_t conn)
Initialized an curl multiperform handler which allows fetch feed metadata chunk by chunk.
Definition openvasd.c:639
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)
Create a new Openvasd target.
Definition openvasd.c:2165
void openvasd_result_free(openvasd_result_t result)
Definition openvasd.c:1070
char * openvasd_get_result_member_str(openvasd_result_t result, openvasd_result_member_string_t member)
Definition openvasd.c:1016
#define RESP_CODE_OK
Definition openvasd.c:34
int openvasd_get_scan_progress(openvasd_connector_t conn)
Definition openvasd.c:1361
enum openvas_request_method openvasd_req_method_t
Definition openvasd.c:137
static struct curl_slist * init_customheader(const gchar *apikey, gboolean contenttype)
Definition openvasd.c:363
static void add_port_to_scan_json(gpointer range, gpointer p_array)
Definition openvasd.c:1852
static openvasd_status_t get_status_code_from_openvas(const gchar *status_val)
Definition openvasd.c:1367
char * openvasd_param_type(openvasd_param_t *param)
Get the parameter type.
Definition openvasd.c:1732
openvasd_connector_t openvasd_connector_new(void)
Initialize an openvasd connector.
Definition openvasd.c:231
struct openvasd_curlm openvasd_curlm_t
Wrapps a CURLM * handler and the custom header.
openvasd_resp_t openvasd_get_health_alive(openvasd_connector_t conn)
Definition openvasd.c:1508
void openvasd_target_set_finished_hosts(openvasd_target_t *target, const gchar *finished_hosts)
Set the finished hosts of an Openvasd target.
Definition openvasd.c:2194
struct openvasd_string * openvasd_vt_stream_t
Definition openvasd.c:55
static int get_member_value_or_fail(cJSON *reader, const gchar *member)
Get the value from an object or error.
Definition openvasd.c:1263
void openvasd_vt_single_free(openvasd_vt_single_t *vt_single)
Free a single Openvasd VT, including all preference values.
Definition openvasd.c:2291
openvasd_resp_t openvasd_get_version(openvasd_connector_t conn)
Request HEAD.
Definition openvasd.c:597
static size_t response_callback_fn(void *ptr, size_t size, size_t nmemb, void *struct_string)
Call back function to stored the response.
Definition openvasd.c:349
char * openvasd_param_default(openvasd_param_t *param)
Get the parameter default.
Definition openvasd.c:1746
static void add_scan_preferences_to_scan_json(gpointer key, gpointer val, gpointer scan_prefs_array)
Definition openvasd.c:1903
openvasd_resp_t openvasd_get_vts(openvasd_connector_t conn)
Get VT's metadata.
Definition openvasd.c:734
int openvasd_get_vt_stream(openvasd_connector_t conn)
Get a new feed metadata chunk.
Definition openvasd.c:703
openvasd_resp_t openvasd_start_scan(openvasd_connector_t conn, gchar *data)
Definition openvasd.c:775
static void add_vts_to_scan_json(gpointer single_vt, gpointer vts_array)
Definition openvasd.c:1913
void openvasd_vt_single_add_value(openvasd_vt_single_t *vt_single, const gchar *name, const gchar *value)
Add a preference value to an Openvasd VT.
Definition openvasd.c:2312
static int parse_status(const gchar *body, openvasd_scan_status_t status_info)
Definition openvasd.c:1388
openvasd_resp_t openvasd_get_health_started(openvasd_connector_t conn)
Definition openvasd.c:1577
openvasd_error_t openvasd_connector_free(openvasd_connector_t conn)
Build a openvasd connector.
Definition openvasd.c:307
static openvasd_vt_stream_t openvasd_vt_stream_new(void)
Allocate the vt stream struct to hold the response and the curlm handler.
Definition openvasd.c:182
static void openvasd_vt_stream_reset(openvasd_vt_stream_t s)
Reinitialize the string struct to hold the response.
Definition openvasd.c:215
openvasd_resp_t openvasd_delete_scan(openvasd_connector_t conn)
Definition openvasd.c:1454
void openvasd_response_cleanup(openvasd_resp_t resp)
Free an openvasd response struct.
Definition openvasd.c:332
static int openvasd_get_scan_progress_ext(openvasd_connector_t conn, openvasd_resp_t response)
Definition openvasd.c:1274
void openvasd_target_add_alive_test_methods(openvasd_target_t *target, gboolean icmp, gboolean tcp_syn, gboolean tcp_ack, gboolean arp, gboolean consider_alive)
Add alive test methods to Openvasd target.
Definition openvasd.c:2234
gchar * openvasd_vt_stream_str(openvasd_connector_t conn)
Definition openvasd.c:680
openvasd_resp_t openvasd_stop_scan(openvasd_connector_t conn)
Definition openvasd.c:882
openvasd_resp_t openvasd_get_health_ready(openvasd_connector_t conn)
Definition openvasd.c:1543
openvas_request_method
Request methods.
Definition openvasd.c:130
@ HEAD
Definition openvasd.c:133
@ GET
Definition openvasd.c:132
@ POST
Definition openvasd.c:131
@ DELETE
Definition openvasd.c:134
char * openvasd_param_id(openvasd_param_t *param)
Get the parameter id.
Definition openvasd.c:1690
static int parse_results(const gchar *body, GSList **results)
Definition openvasd.c:1091
static openvasd_param_t * openvasd_param_new(char *id, gchar *name, gchar *defval, gchar *description, gchar *type, int mandatory)
Create a new Openvasd parameter.
Definition openvasd.c:1653
static openvasd_resp_t openvasd_send_request(CURL *curl, const gchar *header_name, openvasd_resp_t response)
Send request.
Definition openvasd.c:561
static openvasd_curlm_t * openvasd_curlm_handler_new(void)
Allocate openvasd curl handler.
Definition openvasd.c:145
int openvasd_parsed_scans_preferences(openvasd_connector_t conn, GSList **params)
Definition openvasd.c:1769
openvasd_vt_single_t * openvasd_vt_single_new(const gchar *vt_id)
Create a new single Openvasd VT.
Definition openvasd.c:2273
static void openvasd_vt_stream_free(openvasd_vt_stream_t s)
Cleanup the string struct to hold the response and the curl multiperform handler.
Definition openvasd.c:198
openvasd_error_t openvasd_connector_builder(openvasd_connector_t conn, openvasd_conn_opt_t opt, const void *val)
Build a openvasd connector.
Definition openvasd.c:254
openvasd_resp_t openvasd_get_scan_status(openvasd_connector_t conn)
Definition openvasd.c:1205
API for Openvas Daemon communication.
@ ID
Definition openvasd.h:79
@ PORT
Definition openvasd.h:80
enum OPENVASD_RESULT_MEMBER_STRING openvasd_result_member_string_t
Definition openvasd.h:117
struct openvasd_credential openvasd_credential_t
Definition openvasd.h:220
@ OPENVASD_INVALID_OPT
Definition openvasd.h:42
@ OPENVASD_INVALID_VALUE
Definition openvasd.h:44
@ OPENVASD_OK
Definition openvasd.h:46
struct openvasd_vt_single openvasd_vt_single_t
Definition openvasd.h:218
struct openvasd_connector * openvasd_connector_t
Definition openvasd.h:125
struct openvasd_target openvasd_target_t
Definition openvasd.h:216
@ OPENVASD_API_KEY
Definition openvasd.h:55
@ OPENVASD_SERVER
Definition openvasd.h:56
@ OPENVASD_CA_CERT
Definition openvasd.h:52
@ OPENVASD_KEY
Definition openvasd.h:54
@ OPENVASD_SCAN_ID
Definition openvasd.h:58
@ OPENVASD_CERT
Definition openvasd.h:53
@ OPENVASD_PORT
Definition openvasd.h:59
@ OPENVASD_HOST
Definition openvasd.h:57
struct openvasd_param openvasd_param_t
Definition openvasd.h:187
openvasd_status_t
Openvasd scan status.
Definition openvasd.h:87
@ OPENVASD_SCAN_STATUS_SUCCEEDED
Definition openvasd.h:94
@ OPENVASD_SCAN_STATUS_RUNNING
Definition openvasd.h:92
@ OPENVASD_SCAN_STATUS_STOPPED
Definition openvasd.h:93
@ OPENVASD_SCAN_STATUS_STORED
Definition openvasd.h:90
@ OPENVASD_SCAN_STATUS_REQUESTED
Definition openvasd.h:91
@ OPENVASD_SCAN_STATUS_ERROR
Definition openvasd.h:88
@ OPENVASD_SCAN_STATUS_FAILED
Definition openvasd.h:89
struct openvasd_result * openvasd_result_t
Definition openvasd.h:123
enum OPENVASD_CONNECTOR_OPTS openvasd_conn_opt_t
Definition openvasd.h:119
enum OPENVASD_RESULT_MEMBER_INT openvasd_result_member_int_t
Definition openvasd.h:115
struct openvasd_scan_status * openvasd_scan_status_t
Definition openvasd.h:127
struct openvasd_response * openvasd_resp_t
Definition openvasd.h:113
enum OPENVASD_ERROR openvasd_error_t
Definition openvasd.h:121
@ DETAIL_NAME
Definition openvasd.h:70
@ DETAIL_VALUE
Definition openvasd.h:71
@ DETAIL_SOURCE_DESCRIPTION
Definition openvasd.h:74
@ PROTOCOL
Definition openvasd.h:68
@ DETAIL_SOURCE_NAME
Definition openvasd.h:72
@ DETAIL_SOURCE_TYPE
Definition openvasd.h:73
@ HOSTNAME
Definition openvasd.h:66
@ MESSAGE
Definition openvasd.h:69
@ TYPE
Definition openvasd.h:64
@ IP_ADDRESS
Definition openvasd.h:65
@ OID
Definition openvasd.h:67
Struct holding the data for connecting with Openvasd.
Definition openvasd.c:61
openvasd_vt_stream_t stream_resp
Definition openvasd.c:70
gchar * apikey
Definition openvasd.c:65
gchar * server
Definition openvasd.c:66
gchar * key
Definition openvasd.c:64
gchar * cert
Definition openvasd.c:63
int port
Definition openvasd.c:69
gchar * ca_cert
Definition openvasd.c:62
gchar * scan_id
Definition openvasd.c:68
gchar * host
Definition openvasd.c:67
Struct credential information for Openvasd.
Definition openvasd.c:90
gchar * type
Definition openvasd.c:91
gchar * port
Definition openvasd.c:93
gchar * service
Definition openvasd.c:92
GHashTable * auth_data
Definition openvasd.c:94
Wrapps a CURLM * handler and the custom header.
Definition openvasd.c:40
CURLM * h
Definition openvasd.c:41
struct curl_slist * customheader
Definition openvasd.c:42
Struct holding options for Openvasd parameters.
Definition openvasd.c:77
gchar * id
Definition openvasd.c:78
gchar * description
Definition openvasd.c:81
gchar * defval
Definition openvasd.c:80
gchar * name
Definition openvasd.c:79
int mandatory
Definition openvasd.c:83
gchar * type
Definition openvasd.c:82
gchar * header
Definition openvasd.h:101
gchar * body
Definition openvasd.h:100
long code
Definition openvasd.h:99
Struct to hold an scan result.
Definition openvasd.h:23
int port
Definition openvasd.h:29
gchar * ip_address
Definition openvasd.h:26
gchar * oid
Definition openvasd.h:28
gchar * protocol
Definition openvasd.h:30
gchar * detail_source_name
Definition openvasd.h:35
gchar * message
Definition openvasd.h:31
gchar * type
Definition openvasd.h:25
gchar * detail_source_description
Definition openvasd.h:36
gchar * hostname
Definition openvasd.h:27
gchar * detail_name
Definition openvasd.h:32
unsigned long id
Definition openvasd.h:24
gchar * detail_value
Definition openvasd.h:33
gchar * detail_source_type
Definition openvasd.h:34
Definition openvasd.h:105
int progress
Definition openvasd.h:108
time_t start_time
Definition openvasd.h:106
long response_code
Definition openvasd.h:110
time_t end_time
Definition openvasd.h:107
openvasd_status_t status
Definition openvasd.h:109
Define a string struct for storing the response and the curl handler.
Definition openvasd.c:49
openvasd_curlm_t * curl_hnd
Definition openvasd.c:52
gchar * ptr
Definition openvasd.c:50
size_t len
Definition openvasd.c:51
Struct holding target information.
Definition openvasd.c:101
int reverse_lookup_only
Definition openvasd.c:114
gboolean icmp
Definition openvasd.c:108
gchar * ports
Definition openvasd.c:106
gboolean tcp_ack
Definition openvasd.c:110
gchar * exclude_hosts
Definition openvasd.c:104
int reverse_lookup_unify
Definition openvasd.c:113
gboolean arp
Definition openvasd.c:111
GSList * credentials
Definition openvasd.c:103
gboolean tcp_syn
Definition openvasd.c:109
gboolean consider_alive
Definition openvasd.c:112
gchar * finished_hosts
Definition openvasd.c:107
gchar * hosts
Definition openvasd.c:105
gchar * scan_id
Definition openvasd.c:102
Struct holding vt information.
Definition openvasd.c:121
gchar * vt_id
Definition openvasd.c:122
GHashTable * vt_values
Definition openvasd.c:123
A port range.
Definition networking.h:35
int start
Definition networking.h:40
port_protocol_t type
Definition networking.h:41
int end
Definition networking.h:38