Greenbone Vulnerability Management Libraries 22.22.0
openvasd.c
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Greenbone AG
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later
4 */
5
10
11#include "openvasd.h"
12
13#include "../base/array.h"
14#include "../base/networking.h"
15#include "../http/httputils.h"
16#include "../util/json.h"
17
18#include <cjson/cJSON.h>
19#include <netinet/in.h>
20#include <stddef.h>
21#include <stdio.h>
22#include <stdlib.h>
23#include <unistd.h>
24
25#undef G_LOG_DOMAIN
29#define G_LOG_DOMAIN "libgvm ovd"
30
31#define RESP_CODE_ERR -1
32#define RESP_CODE_OK 0
33
38{
39 gchar *ca_cert;
40 gchar *cert;
41 gchar *key;
42 gchar *apikey;
43 gchar *host;
44 gchar *scan_id;
45 int port;
46 gchar *protocol;
47 gvm_http_response_stream_t stream_resp;
48};
49
54{
55 gchar *id;
56 gchar *name;
57 gchar *defval;
58 gchar *description;
59 gchar *type;
61};
62
67{
68 gchar *type;
69 gchar *service;
70 gchar *port;
71 GHashTable *auth_data;
72};
73
78{
79 gchar *scan_id;
80 GSList *credentials;
82 gchar *hosts;
83 gchar *ports;
85 gboolean icmp;
86 gboolean tcp_syn;
87 gboolean tcp_ack;
88 gboolean arp;
89 gboolean consider_alive;
92};
93
98{
99 gchar *vt_id;
100 GHashTable *vt_values;
101};
102
110{
111 openvasd_connector_t connector;
112 gvm_http_response_stream_t stream;
113
114 connector = g_malloc0 (sizeof (struct openvasd_connector));
115 stream = gvm_http_response_stream_new ();
116 connector->stream_resp = stream;
117
118 return connector;
119}
120
133 const void *val)
134{
135 if (conn == NULL)
136 conn = openvasd_connector_new ();
137
138 if (opt < OPENVASD_CA_CERT || opt > OPENVASD_PORT)
140
141 if (val == NULL)
143
144 switch (opt)
145 {
146 case OPENVASD_CA_CERT:
147 conn->ca_cert = g_strdup ((char *) val);
148 break;
149 case OPENVASD_CERT:
150 conn->cert = g_strdup ((char *) val);
151 break;
152 case OPENVASD_KEY:
153 conn->key = g_strdup ((char *) val);
154 break;
155 case OPENVASD_API_KEY:
156 conn->apikey = g_strdup ((char *) val);
157 break;
159 if (g_strcmp0 ((char *) val, "http") != 0
160 && g_strcmp0 ((char *) val, "https") != 0)
162 conn->protocol = g_strdup ((char *) val);
163 break;
164 case OPENVASD_HOST:
165 conn->host = g_strdup ((char *) val);
166 break;
167 case OPENVASD_SCAN_ID:
168 conn->scan_id = g_strdup ((const gchar *) val);
169 break;
170 case OPENVASD_PORT:
171 default:
172 conn->port = *((int *) val);
173 break;
174 };
175
176 return OPENVASD_OK;
177}
178
189{
190 if (conn == NULL)
191 return OPENVASD_OK;
192
193 g_free (conn->ca_cert);
194 g_free (conn->cert);
195 g_free (conn->key);
196 g_free (conn->apikey);
197 g_free (conn->protocol);
198 g_free (conn->host);
199 g_free (conn->scan_id);
200 gvm_http_response_stream_free (conn->stream_resp);
201 g_free (conn);
202 conn = NULL;
203
204 return OPENVASD_OK;
205}
206
212void
214{
215 if (resp == NULL)
216 return;
217
218 g_free (resp->body);
219 g_free (resp->header);
220 g_free (resp);
221 resp = NULL;
222}
223
224static gvm_http_headers_t *
225init_customheader (const gchar *apikey, gboolean contenttype)
226{
227 gvm_http_headers_t *headers = gvm_http_headers_new ();
228
229 // Set API KEY
230 if (apikey)
231 {
232 GString *xapikey = g_string_new ("X-API-KEY: ");
233 g_string_append (xapikey, apikey);
234
235 if (!gvm_http_add_header (headers, xapikey->str))
236 g_warning ("%s: Not possible to set API-KEY", __func__);
237
238 g_string_free (xapikey, TRUE);
239 }
240
241 // Set Content-Type
242 if (contenttype)
243 {
244 if (!gvm_http_add_header (headers, "Content-Type: application/json"))
245 g_warning ("%s: Not possible to set Content-Type", __func__);
246 }
247
248 return headers;
249}
250
265static openvasd_resp_t
266openvasd_send_request (openvasd_connector_t conn, gvm_http_method_t method,
267 const gchar *path, const gchar *data,
268 const gchar *header_name)
269{
270 openvasd_resp_t response = g_malloc0 (sizeof (struct openvasd_response));
271 response->code = RESP_CODE_ERR;
272 response->body = NULL;
273 response->header = NULL;
274
275 if (!conn)
276 {
277 g_warning ("openvasd_send_request_test: Invalid connector");
278 response->body = g_strdup ("{\"error\": \"Missing openvasd connector\"}");
279 return response;
280 }
281
282 gchar *url = g_strdup_printf ("%s://%s:%d%s", conn->protocol, conn->host,
283 conn->port, path);
284
285 if (!conn->stream_resp)
286 {
287 conn->stream_resp = g_malloc0 (sizeof (struct gvm_http_response_stream));
288 }
289
290 gvm_http_headers_t *custom_headers =
291 init_customheader (conn->apikey, data ? TRUE : FALSE);
292
293 // Send request
294 gvm_http_response_t *http_response =
295 gvm_http_request (url, method, data, custom_headers, conn->ca_cert,
296 conn->cert, conn->key, conn->stream_resp);
297
298 // Check for request errors
299 if (http_response->http_status == -1)
300 {
301 g_warning ("%s: Error performing CURL request", __func__);
302 response->body = g_strdup ("{\"error\": \"Error sending request\"}");
303 gvm_http_response_cleanup (http_response);
304 g_free (url);
305 gvm_http_headers_free (custom_headers);
306 return response;
307 }
308
309 // Populate response struct
310 response->code = (int) http_response->http_status;
311 response->body = g_strdup (
312 http_response->data ? http_response->data : "{\"error\": \"No response\"}");
313
314 // Extract specific header if requested
315 if (header_name)
316 {
317 struct curl_header *hname;
318 if (curl_easy_header (http_response->http->handler, header_name, 0,
319 CURLH_HEADER, -1, &hname)
320 == CURLHE_OK)
321 {
322 response->header = g_strdup (hname->value);
323 }
324 }
325
326 // Cleanup
327 gvm_http_response_cleanup (http_response);
328 g_free (url);
329 gvm_http_headers_free (custom_headers);
330
331 return response;
332}
333
343{
344 openvasd_resp_t response = NULL;
345
346 response = openvasd_send_request (conn, HEAD, "/", NULL, NULL);
347
349 return response;
350}
351
366{
367 GString *path;
368 openvasd_resp_t response = NULL;
369 gvm_http_headers_t *customheader = NULL;
370
371 response = g_malloc0 (sizeof (struct openvasd_response));
372
373 path = g_string_new ("/vts?information=1");
374 gchar *url = g_strdup_printf ("%s://%s:%d%s", conn->protocol, conn->host,
375 conn->port, path->str);
376 customheader = init_customheader (conn->apikey, FALSE);
377
378 if (!conn->stream_resp)
379 {
380 conn->stream_resp = g_malloc0 (sizeof (struct gvm_http_response_stream));
381 }
382
383 gvm_http_multi_t *multi_handle = gvm_http_multi_new ();
384 if (!multi_handle)
385 {
386 g_warning ("%s: Failed to initialize curl multi-handle", __func__);
387 g_string_free (path, TRUE);
388 g_free (url);
389 response->code = RESP_CODE_ERR;
390 response->body =
391 g_strdup ("{\"error\": \"Failed to initialize multi-handle\"}");
392 return response;
393 }
394
395 // Initialize request using curlutils
396 gvm_http_t *http = gvm_http_new (url, GET, NULL, customheader, conn->ca_cert,
397 conn->cert, conn->key, conn->stream_resp);
398
399 g_string_free (path, TRUE);
400 g_free (url);
401
402 // Check if curl handle was created properly
403 if (!http || !http->handler)
404 {
405 g_warning ("%s: Failed to initialize curl request", __func__);
406 gvm_http_headers_free (customheader);
407 gvm_http_multi_free (multi_handle);
408 response->code = RESP_CODE_ERR;
409 response->body =
410 g_strdup ("{\"error\": \"Failed to initialize CURL request\"}");
411 return response;
412 }
413
414 gvm_http_multi_result_t multi_add_result =
415 gvm_http_multi_add_handler (multi_handle, http);
416 if (multi_add_result != GVM_HTTP_OK)
417 {
418 g_warning ("%s: Failed to add CURL handle to multi", __func__);
419 gvm_http_multi_handler_free (multi_handle, http);
420 gvm_http_headers_free (customheader);
421 gvm_http_multi_free (multi_handle);
422 response->code = RESP_CODE_ERR;
423 response->body =
424 g_strdup ("{\"error\": \"Failed to add CURL handle to multi\"}");
425 return response;
426 }
427
428 conn->stream_resp->multi_handler = multi_handle;
429 conn->stream_resp->multi_handler->headers = customheader;
430
431 g_debug ("%s: Multi handle initialized successfully", __func__);
432
433 response->code = RESP_CODE_OK;
434 return response;
435}
436
437void
439{
440 gvm_http_response_stream_reset (conn->stream_resp);
441}
442
443gchar *
445{
446 return conn->stream_resp->data;
447}
448
449size_t
451{
452 return conn->stream_resp->length;
453}
454
466int
468{
469 static int running = 0;
470
471 gvm_http_multi_t *multi = conn->stream_resp->multi_handler;
472 if (!multi || !multi->handler)
473 {
474 g_warning ("%s: Invalid multi-handler", __func__);
475 return -1;
476 }
477
478 gvm_http_multi_result_t mc = gvm_http_multi_perform (multi, &running);
479
480 if (mc == GVM_HTTP_OK && running)
481 {
482 /* wait for activity, timeout, or "nothing" */
483 CURLMcode poll_result =
484 curl_multi_poll (multi->handler, NULL, 0, 5000, NULL);
485 if (poll_result != CURLM_OK)
486 {
487 g_warning ("%s: error on curl_multi_poll(): %d\n", __func__,
488 poll_result);
489 return -1;
490 }
491 }
492
493 return running;
494}
495
506{
507 GString *path;
508 openvasd_resp_t response = NULL;
509
510 path = g_string_new ("/vts?information=1");
511 response = openvasd_send_request (conn, GET, path->str, NULL, NULL);
512
513 g_string_free (path, TRUE);
514
515 if (response->code != RESP_CODE_ERR)
516 response->body = g_strdup (openvasd_vt_stream_str (conn));
517
519 return response;
520}
521
532{
533 openvasd_resp_t response = NULL;
534 cJSON *parser = NULL;
535 GString *path;
536
537 response = openvasd_send_request (conn, POST, "/scans", data, NULL);
538
539 if (response->code == RESP_CODE_ERR)
540 {
541 if (response->body == NULL)
542 response->body =
543 g_strdup ("{\"error\": \"Storing scan configuration\"}");
544 g_warning ("%s: Error storing scan configuration ", __func__);
546 return response;
547 }
548
549 // Get the Scan ID
550 parser = cJSON_Parse (openvasd_vt_stream_str (conn));
551 if (!parser)
552 {
553 const gchar *error_ptr = cJSON_GetErrorPtr ();
554 g_warning ("%s: Error parsing json string to get the scan ID", __func__);
555 if (error_ptr != NULL)
556 {
557 response->body = g_strdup_printf ("{\"error\": \"%s\"}", error_ptr);
558 g_warning ("%s: %s", __func__, error_ptr);
559 }
560 else
561 {
562 response->body = g_strdup (
563 "{\"error\": \"Parsing json string to get the scan ID\"}");
564 }
565 response->code = RESP_CODE_ERR;
566 cJSON_Delete (parser);
568 return response;
569 }
570
571 conn->scan_id = g_strdup (cJSON_GetStringValue (parser));
572
573 // Start the scan
574 path = g_string_new ("/scans");
575 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
576 {
577 g_string_append (path, "/");
578 g_string_append (path, conn->scan_id);
579 }
580 else
581 {
582 response->code = RESP_CODE_ERR;
583 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
584 g_string_free (path, TRUE);
585 g_warning ("%s: Missing scan ID", __func__);
586 cJSON_Delete (parser);
587 return response;
588 }
589
590 openvasd_response_cleanup (response);
592 response = openvasd_send_request (conn, POST, path->str,
593 "{\"action\": \"start\"}", NULL);
594
595 g_string_free (path, TRUE);
596
597 if (response->code == RESP_CODE_ERR)
598 {
599 if (response->body == NULL)
600 response->body = g_strdup ("{\"error\": \"Starting the scan.\"}");
601 g_warning ("%s: Error starting the scan.", __func__);
602 cJSON_Delete (parser);
603 return response;
604 }
605
606 cJSON_Delete (parser);
607 response->body = g_strdup (openvasd_vt_stream_str (conn));
609 return response;
610}
611
614{
615 openvasd_resp_t response;
616 GString *path;
617
618 // Stop the scan
619 path = g_string_new ("/scans");
620 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
621 {
622 g_string_append (path, "/");
623 g_string_append (path, conn->scan_id);
624 }
625 else
626 {
627 response = g_malloc0 (sizeof (struct openvasd_response));
628 response->code = RESP_CODE_ERR;
629 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
630 g_string_free (path, TRUE);
631 g_warning ("%s: Missing scan ID", __func__);
632 return response;
633 }
634
635 response = openvasd_send_request (conn, POST, path->str,
636 "{\"action\": \"stop\"}", NULL);
637
638 g_string_free (path, TRUE);
639
640 if (response->code != RESP_CODE_ERR)
641 response->body = g_strdup (openvasd_vt_stream_str (conn));
642
644 return response;
645}
646
649{
650 openvasd_resp_t response = NULL;
651 GString *path = NULL;
652
653 path = g_string_new ("/scans");
654 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
655 {
656 g_string_append (path, "/");
657 g_string_append (path, conn->scan_id);
658 if (last > first)
659 g_string_append_printf (path, "/results?range%ld-%ld", first, last);
660 else if (last < first)
661 g_string_append_printf (path, "/results?range=%ld", first);
662 else
663 g_string_append (path, "/results");
664 }
665 else
666 {
667 response = g_malloc0 (sizeof (struct openvasd_response));
668 response->code = RESP_CODE_ERR;
669 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
670 g_string_free (path, TRUE);
671 g_warning ("%s: Missing scan ID", __func__);
672 return response;
673 }
674
675 response = openvasd_send_request (conn, GET, path->str, NULL, NULL);
676 g_string_free (path, TRUE);
677
678 if (response->code != RESP_CODE_ERR)
679 response->body = g_strdup (openvasd_vt_stream_str (conn));
680 else
681 {
682 g_warning ("%s: Not possible to get scan results", __func__);
683 response->body =
684 g_strdup ("{\"error\": \"Not possible to get scan results\"}");
685 }
686
688 return response;
689}
690
692openvasd_result_new (unsigned long id, gchar *type, gchar *ip_address,
693 gchar *hostname, gchar *oid, gchar *port, gchar *protocol,
694 gchar *message, gchar *detail_name, gchar *detail_value,
695 gchar *detail_source_type, gchar *detail_source_name,
696 gchar *detail_source_description)
697{
698 openvasd_result_t result = g_malloc0 (sizeof (struct openvasd_result));
699
700 result->id = id;
701 result->type = g_strdup (type);
702 result->ip_address = g_strdup (ip_address);
703 result->hostname = g_strdup (hostname);
704 result->oid = g_strdup (oid);
705 result->message = g_strdup (message);
706 result->detail_name = g_strdup (detail_name);
707 result->detail_value = g_strdup (detail_value);
708 result->detail_source_name = g_strdup (detail_source_name);
709 result->detail_source_type = g_strdup (detail_source_type);
710 result->detail_source_description = g_strdup (detail_source_description);
711
712 if (!g_strcmp0 (type, "host_detail"))
713 result->port = g_strdup ("general/Host_Details");
714 else if (port == NULL || (!g_strcmp0 (port, "0") && protocol))
715 result->port = g_strdup_printf ("general/%s", protocol);
716 else if (protocol)
717 result->port = g_strdup_printf ("%s/%s", port, protocol);
718 else
719 result->port = g_strdup_printf ("general/tcp");
720
721 return result;
722}
723
724char *
727{
728 if (!result)
729 return NULL;
730 switch (member)
731 {
732 case TYPE:
733 return result->type;
734
735 case IP_ADDRESS:
736 return result->ip_address;
737 case HOSTNAME:
738 return result->hostname;
739 case OID:
740 return result->oid;
741 case PORT:
742 return result->port;
743 case MESSAGE:
744 return result->message;
745 case DETAIL_NAME:
746 return result->detail_name;
747 case DETAIL_VALUE:
748 return result->detail_value;
750 return result->detail_source_name;
752 return result->detail_source_type;
754 return result->detail_source_description;
755 default:
756 return NULL;
757 }
758}
759
760int
763{
764 if (!result)
765 return -1;
766
767 switch (member)
768 {
769 case ID:
770 return result->id;
771 default:
772 return -1;
773 }
774}
775
776void
778{
779 if (result == NULL)
780 return;
781
782 g_free (result->type);
783 g_free (result->ip_address);
784 g_free (result->hostname);
785 g_free (result->oid);
786 g_free (result->port);
787 g_free (result->message);
788 g_free (result->detail_name);
789 g_free (result->detail_value);
790 g_free (result->detail_source_name);
791 g_free (result->detail_source_type);
792 g_free (result->detail_source_description);
793 g_free (result);
794 result = NULL;
795}
796
797static int
798parse_results (const gchar *body, GSList **results)
799{
800 cJSON *parser;
801 cJSON *result_obj = NULL;
802 const gchar *err = NULL;
803 openvasd_result_t result = NULL;
804 int ret = -1;
805
806 parser = cJSON_Parse (body);
807 if (parser == NULL)
808 {
809 err = cJSON_GetErrorPtr ();
810 goto res_cleanup;
811 }
812 if (!cJSON_IsArray (parser))
813 {
814 // No results. No information.
815 goto res_cleanup;
816 }
817
818 cJSON_ArrayForEach (result_obj, parser)
819 {
820 cJSON *item;
821 gchar *port = NULL;
822 gchar *detail_name = NULL;
823 gchar *detail_value = NULL;
824 gchar *detail_source_type = NULL;
825 gchar *detail_source_name = NULL;
826 gchar *detail_source_description = NULL;
827
828 if (!cJSON_IsObject (result_obj))
829 // error
830 goto res_cleanup;
831
832 item = cJSON_GetObjectItem (result_obj, "detail");
833 if (item != NULL && cJSON_IsObject (item))
834 {
835 cJSON *detail_obj = NULL;
836
837 detail_name = gvm_json_obj_str (item, "name");
838 detail_value = gvm_json_obj_str (item, "value");
839
840 detail_obj = cJSON_GetObjectItem (item, "source");
841 if (detail_obj && cJSON_IsObject (detail_obj))
842 {
843 detail_source_type = gvm_json_obj_str (detail_obj, "type");
844 detail_source_name = gvm_json_obj_str (detail_obj, "name");
845 detail_source_description =
846 gvm_json_obj_str (detail_obj, "description");
847 }
848 }
849 port = g_strdup_printf ("%d", gvm_json_obj_int (result_obj, "port")),
850
851 result = openvasd_result_new (
852 gvm_json_obj_double (result_obj, "id"),
853 gvm_json_obj_str (result_obj, "type"),
854 gvm_json_obj_str (result_obj, "ip_address"),
855 gvm_json_obj_str (result_obj, "hostname"),
856 gvm_json_obj_str (result_obj, "oid"), port,
857 gvm_json_obj_str (result_obj, "protocol"),
858 gvm_json_obj_str (result_obj, "message"), detail_name, detail_value,
859 detail_source_type, detail_source_name, detail_source_description);
860
861 g_free (port);
862 *results = g_slist_append (*results, result);
863 ret = 200;
864 }
865
866res_cleanup:
867 if (err != NULL)
868 {
869 g_warning ("%s: Unable to parse scan results. Reason: %s", __func__, err);
870 }
871 cJSON_Delete (parser);
872
873 return ret;
874}
875
876int
878 unsigned long last, GSList **results)
879{
880 int ret;
881 openvasd_resp_t resp;
882
883 resp = openvasd_get_scan_results (conn, first, last);
884 if (resp->code == 200)
885 ret = parse_results (resp->body, results);
886 else
887 ret = resp->code;
888
890
891 return ret;
892}
893
896{
897 openvasd_resp_t response;
898 GString *path = NULL;
899
900 path = g_string_new ("/scans");
901 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
902 {
903 g_string_append (path, "/");
904 g_string_append (path, conn->scan_id);
905 g_string_append (path, "/status");
906 }
907 else
908 {
909 response = g_malloc0 (sizeof (struct openvasd_response));
910 response->code = RESP_CODE_ERR;
911 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
912 g_string_free (path, TRUE);
913 g_warning ("%s: Missing scan ID", __func__);
914 return response;
915 }
916
917 response = openvasd_send_request (conn, GET, path->str, NULL, NULL);
918 g_string_free (path, TRUE);
919
920 if (response->code != RESP_CODE_ERR)
921 response->body = g_strdup (openvasd_vt_stream_str (conn));
922 else
923 {
924 response->body =
925 g_strdup ("{\"error\": \"Not possible to get scan status\"}");
926 g_warning ("%s: Not possible to get scan status", __func__);
927 }
928
930 return response;
931}
932
937static int
938get_member_value_or_fail (cJSON *reader, const gchar *member)
939{
940 int ret;
941
942 if (gvm_json_obj_check_int (reader, member, &ret))
943 return -1;
944
945 return ret;
946}
947
948static int
950 openvasd_resp_t response)
951{
952 cJSON *parser;
953 cJSON *reader = NULL;
954 const gchar *err = NULL;
955 int all = 0, excluded = 0, dead = 0, alive = 0, queued = 0, finished = 0;
956 int running_hosts_progress_sum = 0;
957
958 openvasd_resp_t resp;
959 int progress = -1;
960
961 if (!response && !conn)
962 return -1;
963
964 if (response == NULL)
965 resp = openvasd_get_scan_status (conn);
966 else
967 resp = response;
968
969 if (resp->code == 404)
970 return -2;
971 else if (resp->code != 200)
972 return -1;
973
974 parser = cJSON_Parse (resp->body);
975 if (!parser)
976 {
977 err = cJSON_GetErrorPtr ();
978 goto cleanup;
979 }
980
981 reader = cJSON_GetObjectItem (parser, "host_info");
982 if (reader == NULL)
983 {
984 goto cleanup;
985 }
986 if (!cJSON_IsObject (reader))
987 {
988 // Scan still not started. No information.
989 progress = 0;
990 goto cleanup;
991 }
992
993 // read general hosts count
994 all = get_member_value_or_fail (reader, "all");
995 excluded = get_member_value_or_fail (reader, "excluded");
996 dead = get_member_value_or_fail (reader, "dead");
997 alive = get_member_value_or_fail (reader, "alive");
998 queued = get_member_value_or_fail (reader, "queued");
999 finished = get_member_value_or_fail (reader, "finished");
1000
1001 // read progress of single running hosts
1002 cJSON *scanning;
1003 scanning = cJSON_GetObjectItem (reader, "scanning");
1004 if (scanning != NULL && cJSON_IsObject (scanning))
1005 {
1006 cJSON *host = scanning->child;
1007 while (host)
1008 {
1009 running_hosts_progress_sum += cJSON_GetNumberValue (host);
1010 host = host->next;
1011 }
1012 }
1013
1014 if (all < 0 || excluded < 0 || dead < 0 || alive < 0 || queued < 0
1015 || finished < 0)
1016 {
1017 goto cleanup;
1018 }
1019
1020 if ((all + finished - dead) > 0)
1021 progress = (running_hosts_progress_sum + 100 * (alive + finished))
1022 / (all + finished - dead);
1023 else
1024 progress = 100;
1025
1026cleanup:
1027 if (err != NULL)
1028 g_warning ("%s: Unable to parse scan status. Reason: %s", __func__, err);
1029 cJSON_Delete (parser);
1030
1031 return progress;
1032}
1033
1034int
1039
1040static openvasd_status_t
1041get_status_code_from_openvas (const gchar *status_val)
1042{
1044
1045 if (g_strcmp0 (status_val, "stored") == 0)
1046 status_code = OPENVASD_SCAN_STATUS_STORED;
1047 else if (g_strcmp0 (status_val, "requested") == 0)
1048 status_code = OPENVASD_SCAN_STATUS_REQUESTED;
1049 else if (g_strcmp0 (status_val, "running") == 0)
1050 status_code = OPENVASD_SCAN_STATUS_RUNNING;
1051 else if (g_strcmp0 (status_val, "stopped") == 0)
1052 status_code = OPENVASD_SCAN_STATUS_STOPPED;
1053 else if (g_strcmp0 (status_val, "succeeded") == 0)
1054 status_code = OPENVASD_SCAN_STATUS_SUCCEEDED;
1055 else if (g_strcmp0 (status_val, "interrupted") == 0)
1056 status_code = OPENVASD_SCAN_STATUS_FAILED;
1057
1058 return status_code;
1059}
1060
1061static int
1062parse_status (const gchar *body, openvasd_scan_status_t status_info)
1063{
1064 cJSON *parser;
1065 gchar *status_val = NULL;
1067
1068 if (!status_info)
1069 return -1;
1070
1071 parser = cJSON_Parse (body);
1072 if (parser == NULL)
1073 return -1;
1074
1075 if (gvm_json_obj_check_str (parser, "status", &status_val))
1076 {
1077 cJSON_Delete (parser);
1078 return -1;
1079 }
1080
1081 status_code = get_status_code_from_openvas (status_val);
1082
1083 status_info->status = status_code;
1084 status_info->end_time = gvm_json_obj_double (parser, "end_time");
1085 status_info->start_time = gvm_json_obj_double (parser, "start_time");
1086 cJSON_Delete (parser);
1087
1088 return 0;
1089}
1090
1100{
1101 openvasd_resp_t resp = NULL;
1102 int progress = -1;
1104 openvasd_scan_status_t status_info = NULL;
1105
1106 resp = openvasd_get_scan_status (conn);
1107
1108 status_info = g_malloc0 (sizeof (struct openvasd_scan_status));
1109 if (resp->code != 200 || parse_status (resp->body, status_info) == -1)
1110 {
1111 status_info->status = status_code;
1112 status_info->response_code = resp->code;
1114 return status_info;
1115 }
1116
1117 progress = openvasd_get_scan_progress_ext (NULL, resp);
1119 status_info->progress = progress;
1120
1121 return status_info;
1122}
1123
1126{
1127 openvasd_resp_t response;
1128 GString *path;
1129
1130 // Stop the scan
1131 path = g_string_new ("/scans");
1132 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
1133 {
1134 g_string_append (path, "/");
1135 g_string_append (path, conn->scan_id);
1136 }
1137 else
1138 {
1139 response = g_malloc0 (sizeof (struct openvasd_response));
1140 response->code = RESP_CODE_ERR;
1141 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
1142 g_string_free (path, TRUE);
1143 g_warning ("%s: Missing scan ID", __func__);
1144 return response;
1145 }
1146
1147 response = openvasd_send_request (conn, DELETE, path->str, NULL, NULL);
1148
1149 g_string_free (path, TRUE);
1150
1151 if (response->code != RESP_CODE_ERR)
1152 response->body = g_strdup (openvasd_vt_stream_str (conn));
1153 else
1154 {
1155 response->body =
1156 g_strdup ("{\"error\": \"Not possible to delete scan.\"}");
1157 g_warning ("%s: Not possible to delete scan", __func__);
1158 }
1159
1161 return response;
1162}
1163
1166{
1167 openvasd_resp_t response = NULL;
1168
1169 response = openvasd_send_request (conn, GET, "/health/alive", NULL, NULL);
1170
1171 if (response->code != RESP_CODE_ERR)
1172 response->body = g_strdup (openvasd_vt_stream_str (conn));
1173 else
1174 {
1175 response->body =
1176 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1177 g_warning ("%s: Not possible to get health information", __func__);
1178 }
1179
1181 return response;
1182}
1183
1186{
1187 openvasd_resp_t response = NULL;
1188
1189 response =
1190 openvasd_send_request (conn, GET, "/health/ready", NULL, "feed-version");
1191
1192 if (response->code != RESP_CODE_ERR)
1193 response->body = g_strdup (openvasd_vt_stream_str (conn));
1194 else
1195 {
1196 response->body =
1197 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1198 g_warning ("%s: Not possible to get health information", __func__);
1199 }
1200
1202 return response;
1203}
1204
1207{
1208 openvasd_resp_t response = NULL;
1209
1210 response = openvasd_send_request (conn, GET, "/health/started", NULL, NULL);
1211
1212 if (response->code != RESP_CODE_ERR)
1213 response->body = g_strdup (openvasd_vt_stream_str (conn));
1214 else
1215 {
1216 response->body =
1217 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1218 g_warning ("%s: Not possible to get health information", __func__);
1219 }
1220
1222 return response;
1223}
1224
1228{
1229 openvasd_resp_t response;
1230 gchar *query;
1231 time_t now;
1232
1233 time (&now);
1234
1235 if (!opts.titles || !strcmp (opts.titles, "") || opts.start < 0
1236 || opts.start > now || opts.end < 0 || opts.end > now)
1237 {
1238 response = g_malloc0 (sizeof (struct openvasd_response));
1239 response->code = RESP_CODE_ERR;
1240 response->body =
1241 g_strdup ("{\"error\": \"Couldn't send get_performance command "
1242 "to scanner. Bad or missing parameters.\"}");
1243 return response;
1244 }
1245
1246 query = g_strdup_printf ("/health/performance?start=%d&end=%d&titles=%s",
1247 opts.start, opts.end, opts.titles);
1248 response = openvasd_send_request (conn, GET, query, NULL, NULL);
1249 g_free (query);
1250
1251 if (response->code != RESP_CODE_ERR)
1252 response->body = g_strdup (openvasd_vt_stream_str (conn));
1253 else
1254 {
1255 response->body = g_strdup (
1256 "{\"error\": \"Not possible to get performance information.\"}");
1257 g_warning ("%s: Not possible to get performance information", __func__);
1258 }
1259
1261 return response;
1262}
1263
1264int
1267 gchar **graph, gchar **err)
1268{
1269 openvasd_resp_t resp = NULL;
1270 cJSON *parser;
1271 cJSON *item;
1272 int ret = 0;
1273 resp = openvasd_get_performance (conn, opts);
1274
1275 // No results. No information.
1276 parser = cJSON_Parse (resp->body);
1277 if (parser == NULL)
1278 {
1279 *err = g_strdup ("Unable to parse sensor performance data");
1280 ret = -1;
1281 }
1282 else if (resp->code != 200)
1283 {
1284 parser = cJSON_Parse (resp->body);
1285 item = cJSON_GetObjectItem (parser, "error");
1286 if (item != NULL)
1287 *err = g_strdup (cJSON_GetStringValue (item));
1288 ret = -1;
1289 }
1290 else
1291 {
1292 item = cJSON_GetArrayItem (parser, 0);
1293 if (item != NULL)
1294 *graph = g_strdup (cJSON_GetStringValue (item));
1295 }
1296
1298 cJSON_Delete (parser);
1299
1300 return ret;
1301}
1302
1305{
1306 openvasd_resp_t response = NULL;
1307
1308 response =
1309 openvasd_send_request (conn, GET, "/scans/preferences", NULL, NULL);
1310
1311 if (response->code != RESP_CODE_ERR)
1312 response->body = g_strdup (openvasd_vt_stream_str (conn));
1313 else
1314 {
1315 response->body =
1316 g_strdup ("{\"error\": \"Not possible to get scans preferences.\"}");
1317 g_warning ("%s: Not possible to get scans_preferences", __func__);
1318 }
1319
1321 return response;
1322}
1323
1329static openvasd_param_t *
1330openvasd_param_new (char *id, gchar *name, gchar *defval, gchar *description,
1331 gchar *type, int mandatory)
1332{
1333 openvasd_param_t *param = g_malloc0 (sizeof (openvasd_param_t));
1334
1335 param->id = id;
1336 param->defval = defval;
1337 param->description = description;
1338 param->name = name;
1339 param->mandatory = mandatory;
1340 param->type = type;
1341 return param;
1342}
1343
1349void
1351{
1352 if (!param)
1353 return;
1354 g_free (param->id);
1355 g_free (param->name);
1356 g_free (param->defval);
1357 g_free (param->description);
1358 g_free (param->type);
1359}
1360
1366char *
1368{
1369 if (!param)
1370 return NULL;
1371
1372 return param->id;
1373}
1374
1380char *
1382{
1383 if (!param)
1384 return NULL;
1385
1386 return param->defval;
1387}
1388
1394char *
1396{
1397 if (!param)
1398 return NULL;
1399
1400 return param->description;
1401}
1402
1408char *
1410{
1411 if (!param)
1412 return NULL;
1413
1414 return param->type;
1415}
1416
1422char *
1424{
1425 if (!param)
1426 return NULL;
1427
1428 return param->defval;
1429}
1430
1436int
1438{
1439 if (!param)
1440 return 0;
1441
1442 return param->mandatory;
1443}
1444
1445int
1447{
1448 openvasd_resp_t resp = NULL;
1449 cJSON *parser;
1450 cJSON *param_obj = NULL;
1451 int err = 0;
1452
1453 resp = openvasd_get_scan_preferences (conn);
1454
1455 if (resp->code != 200)
1456 return -1;
1457
1458 // No results. No information.
1459 parser = cJSON_Parse (resp->body);
1460 if (parser == NULL || !cJSON_IsArray (parser))
1461 {
1462 err = 1;
1463 goto prefs_cleanup;
1464 }
1465
1466 cJSON_ArrayForEach (param_obj, parser)
1467 {
1468 gchar *defval = NULL, *param_type = NULL;
1469 openvasd_param_t *param = NULL;
1470 int val, mandatory = 0;
1471 char buf[6];
1472 cJSON *item = NULL;
1473
1474 item = cJSON_GetObjectItem (param_obj, "default");
1475 if (item != NULL)
1476 {
1477 if (cJSON_IsNumber (item))
1478 {
1479 val = item->valueint;
1480 g_snprintf (buf, sizeof (buf), "%d", val);
1481 defval = g_strdup (buf);
1482 param_type = g_strdup ("integer");
1483 }
1484 else if (cJSON_IsString (item))
1485 {
1486 defval = g_strdup (item->valuestring);
1487 param_type = g_strdup ("string");
1488 }
1489 else if (cJSON_IsBool (item))
1490 {
1491 if (cJSON_IsTrue (item))
1492 defval = g_strdup ("yes");
1493 else
1494 defval = g_strdup ("no");
1495 param_type = g_strdup ("boolean");
1496 }
1497 else
1498 {
1499 g_warning ("%s: Unable to parse scan preferences.", __func__);
1500 g_free (defval);
1501 g_free (param_type);
1502 continue;
1503 }
1504 }
1505
1506 param = openvasd_param_new (
1507 g_strdup (gvm_json_obj_str (param_obj, "id")),
1508 g_strdup (gvm_json_obj_str (param_obj, "name")), g_strdup (defval),
1509 g_strdup (gvm_json_obj_str (param_obj, "description")),
1510 g_strdup (param_type), mandatory);
1511 g_free (defval);
1512 g_free (param_type);
1513 *params = g_slist_append (*params, param);
1514 }
1515
1516prefs_cleanup:
1518 cJSON_Delete (parser);
1519 if (err)
1520 {
1521 g_warning ("%s: Unable to parse scan preferences.", __func__);
1522 return -1;
1523 }
1524
1525 return 0;
1526}
1527
1528// Scan config builder
1529static void
1530add_port_to_scan_json (gpointer range, gpointer p_array)
1531{
1532 range_t *ports = range;
1533
1534 cJSON *port = cJSON_CreateObject ();
1535 if (ports->type == 1)
1536 cJSON_AddStringToObject (port, "protocol", "udp");
1537 else
1538 cJSON_AddStringToObject (port, "protocol", "tcp");
1539
1540 cJSON *ranges_array = cJSON_CreateArray ();
1541 cJSON *range_obj = cJSON_CreateObject ();
1542 cJSON_AddNumberToObject (range_obj, "start", ports->start);
1543
1544 if (ports->end > ports->start && ports->end < 65535)
1545 cJSON_AddNumberToObject (range_obj, "end", ports->end);
1546 else
1547 cJSON_AddNumberToObject (range_obj, "end", ports->start);
1548 cJSON_AddItemToArray (ranges_array, range_obj);
1549 cJSON_AddItemToObject (port, "range", ranges_array);
1550 cJSON_AddItemToArray ((cJSON *) p_array, port);
1551}
1552
1553static void
1554add_credential_to_scan_json (gpointer credentials, gpointer cred_array)
1555{
1556 GHashTableIter auth_data_iter;
1557 gchar *auth_data_name, *auth_data_value;
1558 cJSON *cred_obj = NULL;
1559
1560 openvasd_credential_t *cred = credentials;
1561
1562 cred_obj = cJSON_CreateObject ();
1563 cJSON_AddStringToObject (cred_obj, "service", cred->service);
1564
1565 if (cred->port)
1566 {
1567 cJSON_AddNumberToObject (cred_obj, "port", atoi (cred->port));
1568 }
1569
1570 cJSON *cred_type_obj = cJSON_CreateObject ();
1571 g_hash_table_iter_init (&auth_data_iter, cred->auth_data);
1572 while (g_hash_table_iter_next (&auth_data_iter, (gpointer *) &auth_data_name,
1573 (gpointer *) &auth_data_value))
1574 cJSON_AddStringToObject (cred_type_obj, auth_data_name, auth_data_value);
1575 cJSON_AddItemToObject (cred_obj, cred->type, cred_type_obj);
1576
1577 cJSON_AddItemToArray ((cJSON *) cred_array, cred_obj);
1578}
1579
1580static void
1581add_scan_preferences_to_scan_json (gpointer key, gpointer val,
1582 gpointer scan_prefs_array)
1583{
1584 cJSON *pref_obj = cJSON_CreateObject ();
1585 cJSON_AddStringToObject (pref_obj, "id", key);
1586 cJSON_AddStringToObject (pref_obj, "value", val);
1587 cJSON_AddItemToArray (scan_prefs_array, pref_obj);
1588}
1589
1590static void
1591add_vts_to_scan_json (gpointer single_vt, gpointer vts_array)
1592{
1593 GHashTableIter vt_data_iter;
1594 gchar *vt_param_id, *vt_param_value;
1595
1596 openvasd_vt_single_t *vt = single_vt;
1597
1598 cJSON *vt_obj = cJSON_CreateObject ();
1599
1600 cJSON_AddStringToObject (vt_obj, "oid", vt->vt_id);
1601
1602 if (g_hash_table_size (vt->vt_values))
1603 {
1604 cJSON *params_array = cJSON_CreateArray ();
1605
1606 g_hash_table_iter_init (&vt_data_iter, vt->vt_values);
1607 while (g_hash_table_iter_next (&vt_data_iter, (gpointer *) &vt_param_id,
1608 (gpointer *) &vt_param_value))
1609 {
1610 cJSON *param_obj = cJSON_CreateObject ();
1611 cJSON_AddNumberToObject (param_obj, "id", atoi (vt_param_id));
1612 cJSON_AddStringToObject (param_obj, "value", vt_param_value);
1613 cJSON_AddItemToArray (params_array, param_obj);
1614 }
1615 cJSON_AddItemToObject (vt_obj, "parameters", params_array);
1616 }
1617 cJSON_AddItemToArray (vts_array, vt_obj);
1618}
1619
1632char *
1634 GHashTable *scan_preferences, GSList *vts)
1635{
1636 cJSON *scan_obj = NULL;
1637 cJSON *target_obj = NULL;
1638 cJSON *hosts_array = NULL;
1639 cJSON *exclude_hosts_array = NULL;
1640 cJSON *finished_hosts_array = NULL;
1641 gchar *json_str = NULL;
1642
1643 /* Build the message in json format to be published. */
1644 scan_obj = cJSON_CreateObject ();
1645
1646 if (target->scan_id && target->scan_id[0] != '\0')
1647 cJSON_AddStringToObject (scan_obj, "scan_id", target->scan_id);
1648
1649 // begin target
1650 target_obj = cJSON_CreateObject ();
1651
1652 // hosts
1653 hosts_array = cJSON_CreateArray ();
1654 gchar **hosts_list = g_strsplit (target->hosts, ",", 0);
1655 for (int i = 0; hosts_list[i] != NULL; i++)
1656 {
1657 cJSON *host_item = NULL;
1658 host_item = cJSON_CreateString (hosts_list[i]);
1659 cJSON_AddItemToArray (hosts_array, host_item);
1660 }
1661 g_strfreev (hosts_list);
1662 cJSON_AddItemToObject (target_obj, "hosts", hosts_array);
1663
1664 // exclude hosts
1665 if (target->exclude_hosts && target->exclude_hosts[0] != '\0')
1666 {
1667 exclude_hosts_array = cJSON_CreateArray ();
1668 gchar **exclude_hosts_list = g_strsplit (target->exclude_hosts, ",", 0);
1669 for (int i = 0; exclude_hosts_list[i] != NULL; i++)
1670 {
1671 cJSON *exclude_host_item = NULL;
1672 exclude_host_item = cJSON_CreateString (exclude_hosts_list[i]);
1673 cJSON_AddItemToArray (exclude_hosts_array, exclude_host_item);
1674 }
1675 g_strfreev (exclude_hosts_list);
1676 cJSON_AddItemToObject (target_obj, "excluded_hosts", exclude_hosts_array);
1677 }
1678
1679 // finished hosts
1680 if (target->finished_hosts && target->finished_hosts[0] != '\0')
1681 {
1682 finished_hosts_array = cJSON_CreateArray ();
1683 gchar **finished_hosts_list = g_strsplit (target->finished_hosts, ",", 0);
1684 for (int i = 0; finished_hosts_list[i] != NULL; i++)
1685 {
1686 cJSON *finished_host_item = NULL;
1687 finished_host_item = cJSON_CreateString (finished_hosts_list[i]);
1688 cJSON_AddItemToArray (finished_hosts_array, finished_host_item);
1689 }
1690 g_strfreev (hosts_list);
1691 cJSON_AddItemToObject (target_obj, "finished_hosts",
1692 finished_hosts_array);
1693 }
1694
1695 // ports
1696 if (target->ports && target->ports[0] != '\0')
1697 {
1698 cJSON *ports_array = cJSON_CreateArray ();
1699 array_t *ports = port_range_ranges (target->ports);
1700 g_ptr_array_foreach (ports, add_port_to_scan_json, ports_array);
1701 array_free (ports);
1702 cJSON_AddItemToObject (target_obj, "ports", ports_array);
1703 }
1704
1705 // credentials
1706 cJSON *credentials = cJSON_CreateArray ();
1707 g_slist_foreach (target->credentials, add_credential_to_scan_json,
1708 credentials);
1709 cJSON_AddItemToObject (target_obj, "credentials", credentials);
1710
1711 // reverse lookup
1712 if (target->reverse_lookup_unify)
1713 cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", cJSON_True);
1714 else
1715 cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", cJSON_False);
1716
1717 if (target->reverse_lookup_only)
1718 cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", cJSON_True);
1719 else
1720 cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", cJSON_False);
1721
1722 // alive test methods
1723 cJSON *alive_test_methods = cJSON_CreateArray ();
1724 if (target->arp)
1725 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("arp"));
1726 if (target->tcp_ack)
1727 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_ack"));
1728 if (target->tcp_syn)
1729 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_syn"));
1730 if (target->consider_alive)
1731 cJSON_AddItemToArray (alive_test_methods,
1732 cJSON_CreateString ("consider_alive"));
1733 if (target->icmp)
1734 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("icmp"));
1735 cJSON_AddItemToObject (target_obj, "alive_test_methods", alive_test_methods);
1736
1737 cJSON_AddItemToObject (scan_obj, "target", target_obj);
1738
1739 // Begin Scan Preferences
1740 cJSON *scan_prefs_array = cJSON_CreateArray ();
1741 g_hash_table_foreach (scan_preferences, add_scan_preferences_to_scan_json,
1742 scan_prefs_array);
1743 cJSON_AddItemToObject (scan_obj, "scan_preferences", scan_prefs_array);
1744
1745 // Begin VTs
1746 cJSON *vts_array = cJSON_CreateArray ();
1747 g_slist_foreach (vts, add_vts_to_scan_json, vts_array);
1748 cJSON_AddItemToObject (scan_obj, "vts", vts_array);
1749
1750 json_str = cJSON_Print (scan_obj);
1751 cJSON_Delete (scan_obj);
1752 if (json_str == NULL)
1753 g_warning ("%s: Error while creating JSON.", __func__);
1754
1755 return json_str;
1756}
1757
1768openvasd_credential_new (const gchar *type, const gchar *service,
1769 const gchar *port)
1770{
1771 openvasd_credential_t *new_credential;
1772
1773 new_credential = g_malloc0 (sizeof (openvasd_credential_t));
1774
1775 new_credential->type = type ? g_strdup (type) : NULL;
1776 new_credential->service = service ? g_strdup (service) : NULL;
1777 new_credential->port = port ? g_strdup (port) : NULL;
1778 new_credential->auth_data =
1779 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1780
1781 return new_credential;
1782}
1783
1789void
1791{
1792 if (!credential)
1793 return;
1794
1795 g_free (credential->type);
1796 g_free (credential->service);
1797 g_free (credential->port);
1798 g_hash_table_destroy (credential->auth_data);
1799 g_free (credential);
1800}
1801
1809void
1811 const gchar *name, const gchar *value)
1812{
1813 if (credential == NULL || name == NULL)
1814 return;
1815
1816 if (g_regex_match_simple ("^[[:alpha:]][[:alnum:]_]*$", name, 0, 0))
1817 {
1818 if (value)
1819 g_hash_table_replace (credential->auth_data, g_strdup (name),
1820 g_strdup (value));
1821 else
1822 g_hash_table_remove (credential->auth_data, name);
1823 }
1824 else
1825 {
1826 g_warning ("%s: Invalid auth data name: %s", __func__, name);
1827 }
1828}
1829
1843openvasd_target_new (const gchar *scanid, const gchar *hosts,
1844 const gchar *ports, const gchar *exclude_hosts,
1845 int reverse_lookup_unify, int reverse_lookup_only)
1846{
1847 openvasd_target_t *new_target;
1848 new_target = g_malloc0 (sizeof (openvasd_target_t));
1849
1850 if (scanid && *scanid)
1851 new_target->scan_id = g_strdup (scanid);
1852
1853 new_target->exclude_hosts = exclude_hosts ? g_strdup (exclude_hosts) : NULL;
1854 new_target->finished_hosts = NULL;
1855 new_target->hosts = hosts ? g_strdup (hosts) : NULL;
1856 new_target->ports = ports ? g_strdup (ports) : NULL;
1857 new_target->reverse_lookup_unify =
1858 reverse_lookup_unify ? reverse_lookup_unify : 0;
1859 new_target->reverse_lookup_only =
1860 reverse_lookup_only ? reverse_lookup_only : 0;
1861
1862 return new_target;
1863}
1864
1871void
1873 const gchar *finished_hosts)
1874{
1875 g_free (target->finished_hosts);
1876 target->finished_hosts = finished_hosts ? g_strdup (finished_hosts) : NULL;
1877}
1878
1884void
1886{
1887 if (!target)
1888 return;
1889
1890 g_slist_free_full (target->credentials,
1891 (GDestroyNotify) openvasd_credential_free);
1892 g_free (target->exclude_hosts);
1893 g_free (target->finished_hosts);
1894 g_free (target->scan_id);
1895 g_free (target->hosts);
1896 g_free (target->ports);
1897 g_free (target);
1898 target = NULL;
1899}
1900
1911void
1913 gboolean icmp, gboolean tcp_syn,
1914 gboolean tcp_ack, gboolean arp,
1915 gboolean consider_alive)
1916{
1917 if (!target)
1918 return;
1919
1920 target->icmp = icmp;
1921 target->tcp_syn = tcp_syn;
1922 target->tcp_ack = tcp_ack;
1923 target->arp = arp;
1924 target->consider_alive = consider_alive;
1925}
1926
1933void
1935 openvasd_credential_t *credential)
1936{
1937 if (!target || !credential)
1938 return;
1939
1940 target->credentials = g_slist_prepend (target->credentials, credential);
1941}
1942
1951openvasd_vt_single_new (const gchar *vt_id)
1952{
1953 openvasd_vt_single_t *new_vt_single;
1954 new_vt_single = g_malloc0 (sizeof (openvasd_vt_single_t));
1955
1956 new_vt_single->vt_id = vt_id ? g_strdup (vt_id) : NULL;
1957 new_vt_single->vt_values =
1958 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1959
1960 return new_vt_single;
1961}
1962
1968void
1970{
1971 if (!vt_single)
1972 return;
1973
1974 g_hash_table_destroy (vt_single->vt_values);
1975
1976 g_free (vt_single->vt_id);
1977 g_free (vt_single);
1978}
1979
1989void
1991 const gchar *name, const gchar *value)
1992{
1993 g_hash_table_replace (vt_single->vt_values, g_strdup (name),
1994 g_strdup (value));
1995}
void array_free(GPtrArray *array)
Free global array value.
Definition array.c:50
Array utilities.
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
int gvm_json_obj_check_int(cJSON *obj, const gchar *key, int *val)
Get an int field from a JSON object.
Definition json.c:97
int gvm_json_obj_int(cJSON *obj, const gchar *key)
Get an int field from a JSON object.
Definition json.c:120
gchar * gvm_json_obj_str(cJSON *obj, const gchar *key)
Get a string field from a JSON object.
Definition json.c:165
int gvm_json_obj_check_str(cJSON *obj, const gchar *key, gchar **val)
Get a string field from a JSON object.
Definition json.c:142
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:1934
static openvasd_resp_t openvasd_send_request(openvasd_connector_t conn, gvm_http_method_t method, const gchar *path, const gchar *data, const gchar *header_name)
Sends an HTTP(S) request to the OpenVAS daemon using the specified parameters.
Definition openvasd.c:266
void openvasd_param_free(openvasd_param_t *param)
Free an openvasd parameter.
Definition openvasd.c:1350
#define RESP_CODE_ERR
Definition openvasd.c:31
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:1810
int openvasd_get_result_member_int(openvasd_result_t result, openvasd_result_member_int_t member)
Definition openvasd.c:761
void openvasd_target_free(openvasd_target_t *target)
Free an openvasd target, including all added credentials.
Definition openvasd.c:1885
openvasd_scan_status_t openvasd_parsed_scan_status(openvasd_connector_t conn)
Return a struct with the general scan status.
Definition openvasd.c:1099
char * openvasd_param_desc(openvasd_param_t *param)
Get the parameter description.
Definition openvasd.c:1395
void openvasd_reset_vt_stream(openvasd_connector_t conn)
Definition openvasd.c:438
void openvasd_credential_free(openvasd_credential_t *credential)
Free an openvasd credential.
Definition openvasd.c:1790
size_t openvasd_vt_stream_len(openvasd_connector_t conn)
Definition openvasd.c:450
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:1768
openvasd_resp_t openvasd_get_scan_results(openvasd_connector_t conn, long first, long last)
Definition openvasd.c:648
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:1633
char * openvasd_param_name(openvasd_param_t *param)
Get the parameter default.
Definition openvasd.c:1381
static void add_credential_to_scan_json(gpointer credentials, gpointer cred_array)
Definition openvasd.c:1554
openvasd_resp_t openvasd_get_scan_preferences(openvasd_connector_t conn)
Definition openvasd.c:1304
int openvasd_parsed_results(openvasd_connector_t conn, unsigned long first, unsigned long last, GSList **results)
Definition openvasd.c:877
int openvasd_param_mandatory(openvasd_param_t *param)
If the parameter is mandatory.
Definition openvasd.c:1437
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:365
int openvasd_parsed_performance(openvasd_connector_t conn, openvasd_get_performance_opts_t opts, gchar **graph, gchar **err)
Definition openvasd.c:1265
openvasd_resp_t openvasd_get_performance(openvasd_connector_t conn, openvasd_get_performance_opts_t opts)
Definition openvasd.c:1226
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:1843
void openvasd_result_free(openvasd_result_t result)
Definition openvasd.c:777
char * openvasd_get_result_member_str(openvasd_result_t result, openvasd_result_member_string_t member)
Definition openvasd.c:725
#define RESP_CODE_OK
Definition openvasd.c:32
int openvasd_get_scan_progress(openvasd_connector_t conn)
Definition openvasd.c:1035
static void add_port_to_scan_json(gpointer range, gpointer p_array)
Definition openvasd.c:1530
static openvasd_status_t get_status_code_from_openvas(const gchar *status_val)
Definition openvasd.c:1041
char * openvasd_param_type(openvasd_param_t *param)
Get the parameter type.
Definition openvasd.c:1409
openvasd_connector_t openvasd_connector_new(void)
Initialize an openvasd connector.
Definition openvasd.c:109
openvasd_resp_t openvasd_get_health_alive(openvasd_connector_t conn)
Definition openvasd.c:1165
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:1872
openvasd_result_t openvasd_result_new(unsigned long id, gchar *type, gchar *ip_address, gchar *hostname, gchar *oid, gchar *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:692
static int get_member_value_or_fail(cJSON *reader, const gchar *member)
Get the value from an object or error.
Definition openvasd.c:938
void openvasd_vt_single_free(openvasd_vt_single_t *vt_single)
Free a single openvasd VT, including all preference values.
Definition openvasd.c:1969
openvasd_resp_t openvasd_get_version(openvasd_connector_t conn)
Request HEAD.
Definition openvasd.c:342
char * openvasd_param_default(openvasd_param_t *param)
Get the parameter default.
Definition openvasd.c:1423
static void add_scan_preferences_to_scan_json(gpointer key, gpointer val, gpointer scan_prefs_array)
Definition openvasd.c:1581
openvasd_resp_t openvasd_get_vts(openvasd_connector_t conn)
Get VT's metadata.
Definition openvasd.c:505
int openvasd_get_vt_stream(openvasd_connector_t conn)
Get a new feed metadata chunk.
Definition openvasd.c:467
openvasd_resp_t openvasd_start_scan(openvasd_connector_t conn, gchar *data)
Definition openvasd.c:531
static void add_vts_to_scan_json(gpointer single_vt, gpointer vts_array)
Definition openvasd.c:1591
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:1990
static int parse_status(const gchar *body, openvasd_scan_status_t status_info)
Definition openvasd.c:1062
openvasd_resp_t openvasd_get_health_started(openvasd_connector_t conn)
Definition openvasd.c:1206
openvasd_error_t openvasd_connector_free(openvasd_connector_t conn)
Build a openvasd connector.
Definition openvasd.c:188
openvasd_resp_t openvasd_delete_scan(openvasd_connector_t conn)
Definition openvasd.c:1125
void openvasd_response_cleanup(openvasd_resp_t resp)
Free an openvasd response struct.
Definition openvasd.c:213
static int openvasd_get_scan_progress_ext(openvasd_connector_t conn, openvasd_resp_t response)
Definition openvasd.c:949
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:1912
gchar * openvasd_vt_stream_str(openvasd_connector_t conn)
Definition openvasd.c:444
openvasd_resp_t openvasd_stop_scan(openvasd_connector_t conn)
Definition openvasd.c:613
openvasd_resp_t openvasd_get_health_ready(openvasd_connector_t conn)
Definition openvasd.c:1185
static gvm_http_headers_t * init_customheader(const gchar *apikey, gboolean contenttype)
Definition openvasd.c:225
char * openvasd_param_id(openvasd_param_t *param)
Get the parameter id.
Definition openvasd.c:1367
static int parse_results(const gchar *body, GSList **results)
Definition openvasd.c:798
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:1330
int openvasd_parsed_scans_preferences(openvasd_connector_t conn, GSList **params)
Definition openvasd.c:1446
openvasd_vt_single_t * openvasd_vt_single_new(const gchar *vt_id)
Create a new single openvasd VT.
Definition openvasd.c:1951
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:132
openvasd_resp_t openvasd_get_scan_status(openvasd_connector_t conn)
Definition openvasd.c:895
API for Openvas Daemon communication.
@ ID
Definition openvasd.h:78
enum OPENVASD_RESULT_MEMBER_STRING openvasd_result_member_string_t
Definition openvasd.h:122
struct openvasd_credential openvasd_credential_t
Definition openvasd.h:232
@ OPENVASD_INVALID_OPT
Definition openvasd.h:41
@ OPENVASD_INVALID_VALUE
Definition openvasd.h:43
@ OPENVASD_OK
Definition openvasd.h:45
struct openvasd_vt_single openvasd_vt_single_t
Definition openvasd.h:230
struct openvasd_connector * openvasd_connector_t
Definition openvasd.h:130
struct openvasd_target openvasd_target_t
Definition openvasd.h:228
@ OPENVASD_API_KEY
Definition openvasd.h:54
@ OPENVASD_CA_CERT
Definition openvasd.h:51
@ OPENVASD_KEY
Definition openvasd.h:53
@ OPENVASD_SCAN_ID
Definition openvasd.h:57
@ OPENVASD_PROTOCOL
Definition openvasd.h:55
@ OPENVASD_CERT
Definition openvasd.h:52
@ OPENVASD_PORT
Definition openvasd.h:58
@ OPENVASD_HOST
Definition openvasd.h:56
struct openvasd_param openvasd_param_t
Definition openvasd.h:199
openvasd_status_t
Openvasd scan status.
Definition openvasd.h:85
@ OPENVASD_SCAN_STATUS_SUCCEEDED
Definition openvasd.h:92
@ OPENVASD_SCAN_STATUS_RUNNING
Definition openvasd.h:90
@ OPENVASD_SCAN_STATUS_STOPPED
Definition openvasd.h:91
@ OPENVASD_SCAN_STATUS_STORED
Definition openvasd.h:88
@ OPENVASD_SCAN_STATUS_REQUESTED
Definition openvasd.h:89
@ OPENVASD_SCAN_STATUS_ERROR
Definition openvasd.h:86
@ OPENVASD_SCAN_STATUS_FAILED
Definition openvasd.h:87
struct openvasd_result * openvasd_result_t
Definition openvasd.h:128
enum OPENVASD_CONNECTOR_OPTS openvasd_conn_opt_t
Definition openvasd.h:124
enum OPENVASD_RESULT_MEMBER_INT openvasd_result_member_int_t
Definition openvasd.h:120
struct openvasd_scan_status * openvasd_scan_status_t
Definition openvasd.h:132
struct openvasd_response * openvasd_resp_t
Definition openvasd.h:118
enum OPENVASD_ERROR openvasd_error_t
Definition openvasd.h:126
@ DETAIL_NAME
Definition openvasd.h:69
@ DETAIL_VALUE
Definition openvasd.h:70
@ DETAIL_SOURCE_DESCRIPTION
Definition openvasd.h:73
@ DETAIL_SOURCE_NAME
Definition openvasd.h:71
@ PORT
Definition openvasd.h:67
@ DETAIL_SOURCE_TYPE
Definition openvasd.h:72
@ HOSTNAME
Definition openvasd.h:65
@ MESSAGE
Definition openvasd.h:68
@ TYPE
Definition openvasd.h:63
@ IP_ADDRESS
Definition openvasd.h:64
@ OID
Definition openvasd.h:66
Struct holding the data for connecting with openvasd.
Definition openvasd.c:38
gchar * apikey
Definition openvasd.c:42
gvm_http_response_stream_t stream_resp
Definition openvasd.c:47
gchar * key
Definition openvasd.c:41
gchar * cert
Definition openvasd.c:40
int port
Definition openvasd.c:45
gchar * protocol
Definition openvasd.c:46
gchar * ca_cert
Definition openvasd.c:39
gchar * scan_id
Definition openvasd.c:44
gchar * host
Definition openvasd.c:43
Struct credential information for openvasd.
Definition openvasd.c:67
gchar * type
Definition openvasd.c:68
gchar * port
Definition openvasd.c:70
gchar * service
Definition openvasd.c:69
GHashTable * auth_data
Definition openvasd.c:71
Definition openvasd.h:112
const gchar * titles
Definition openvasd.h:115
int end
Definition openvasd.h:114
int start
Definition openvasd.h:113
Struct holding options for openvasd parameters.
Definition openvasd.c:54
gchar * id
Definition openvasd.c:55
gchar * description
Definition openvasd.c:58
gchar * defval
Definition openvasd.c:57
gchar * name
Definition openvasd.c:56
int mandatory
Definition openvasd.c:60
gchar * type
Definition openvasd.c:59
Definition openvasd.h:96
gchar * header
Definition openvasd.h:99
gchar * body
Definition openvasd.h:98
long code
Definition openvasd.h:97
Struct to hold an scan result.
Definition openvasd.h:23
gchar * ip_address
Definition openvasd.h:26
gchar * oid
Definition openvasd.h:28
gchar * detail_source_name
Definition openvasd.h:34
gchar * message
Definition openvasd.h:30
gchar * type
Definition openvasd.h:25
gchar * detail_source_description
Definition openvasd.h:35
gchar * port
Definition openvasd.h:29
gchar * hostname
Definition openvasd.h:27
gchar * detail_name
Definition openvasd.h:31
unsigned long id
Definition openvasd.h:24
gchar * detail_value
Definition openvasd.h:32
gchar * detail_source_type
Definition openvasd.h:33
Definition openvasd.h:103
int progress
Definition openvasd.h:106
time_t start_time
Definition openvasd.h:104
long response_code
Definition openvasd.h:108
time_t end_time
Definition openvasd.h:105
openvasd_status_t status
Definition openvasd.h:107
Struct holding target information.
Definition openvasd.c:78
int reverse_lookup_only
Definition openvasd.c:91
gboolean icmp
Definition openvasd.c:85
gchar * ports
Definition openvasd.c:83
gboolean tcp_ack
Definition openvasd.c:87
gchar * exclude_hosts
Definition openvasd.c:81
int reverse_lookup_unify
Definition openvasd.c:90
gboolean arp
Definition openvasd.c:88
GSList * credentials
Definition openvasd.c:80
gboolean tcp_syn
Definition openvasd.c:86
gboolean consider_alive
Definition openvasd.c:89
gchar * finished_hosts
Definition openvasd.c:84
gchar * hosts
Definition openvasd.c:82
gchar * scan_id
Definition openvasd.c:79
Struct holding vt information.
Definition openvasd.c:98
gchar * vt_id
Definition openvasd.c:99
GHashTable * vt_values
Definition openvasd.c:100
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