Greenbone Vulnerability Management Libraries 22.19.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 *server;
44 gchar *host;
45 gchar *scan_id;
46 int port;
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;
158 case OPENVASD_SERVER:
159 conn->server = g_strdup ((char *) val);
160 break;
161 case OPENVASD_HOST:
162 conn->host = g_strdup ((char *) val);
163 break;
164 case OPENVASD_SCAN_ID:
165 conn->scan_id = g_strdup ((const gchar *) val);
166 break;
167 case OPENVASD_PORT:
168 default:
169 conn->port = *((int *) val);
170 break;
171 };
172
173 return OPENVASD_OK;
174}
175
186{
187 if (conn == NULL)
188 return OPENVASD_OK;
189
190 g_free (conn->ca_cert);
191 g_free (conn->cert);
192 g_free (conn->key);
193 g_free (conn->apikey);
194 g_free (conn->server);
195 g_free (conn->host);
196 g_free (conn->scan_id);
197 gvm_http_response_stream_free (conn->stream_resp);
198 g_free (conn);
199 conn = NULL;
200
201 return OPENVASD_OK;
202}
203
209void
211{
212 if (resp == NULL)
213 return;
214
215 g_free (resp->body);
216 g_free (resp->header);
217 g_free (resp);
218 resp = NULL;
219}
220
221static gvm_http_headers_t *
222init_customheader (const gchar *apikey, gboolean contenttype)
223{
224 gvm_http_headers_t *headers = gvm_http_headers_new ();
225
226 // Set API KEY
227 if (apikey)
228 {
229 GString *xapikey = g_string_new ("X-API-KEY: ");
230 g_string_append (xapikey, apikey);
231
232 if (!gvm_http_add_header (headers, xapikey->str))
233 g_warning ("%s: Not possible to set API-KEY", __func__);
234
235 g_string_free (xapikey, TRUE);
236 }
237
238 // Set Content-Type
239 if (contenttype)
240 {
241 if (!gvm_http_add_header (headers, "Content-Type: application/json"))
242 g_warning ("%s: Not possible to set Content-Type", __func__);
243 }
244
245 return headers;
246}
247
262static openvasd_resp_t
264 gvm_http_method_t method, const gchar *path,
265 const gchar *data,
266 gvm_http_headers_t *custom_headers,
267 const gchar *header_name)
268{
269 openvasd_resp_t response = g_malloc0 (sizeof (struct openvasd_response));
270 response->code = RESP_CODE_ERR;
271 response->body = NULL;
272 response->header = NULL;
273
274 if (!conn)
275 {
276 g_warning ("openvasd_send_request_test: Invalid connector");
277 response->body = g_strdup ("{\"error\": \"Missing openvasd connector\"}");
278 return response;
279 }
280
281 gchar *url = g_strdup_printf ("%s:%d%s", conn->server, conn->port, path);
282
283 if (!conn->stream_resp)
284 {
285 conn->stream_resp = g_malloc0 (sizeof (struct gvm_http_response_stream));
286 }
287
288 // Send request
289 gvm_http_response_t *http_response = gvm_http_request (url, method,
290 data,
291 custom_headers,
292 conn->ca_cert,
293 conn->cert,
294 conn->key,
295 conn->stream_resp);
296
297 // Check for request errors
298 if (http_response->http_status == -1)
299 {
300 g_warning ("%s: Error performing CURL request", __func__);
301 response->body = g_strdup ("{\"error\": \"Error sending request\"}");
302 gvm_http_headers_free (custom_headers);
303 gvm_http_response_cleanup (http_response);
304 g_free (url);
305 return response;
306 }
307
308 // Populate response struct
309 response->code = (int) http_response->http_status;
310 response->body = g_strdup (http_response->data ? http_response->data :
311 "{\"error\": \"No response\"}");
312
313 // Extract specific header if requested
314 if (header_name)
315 {
316 struct curl_header *hname;
317 if (curl_easy_header (http_response->http->handler, header_name, 0,
318 CURLH_HEADER, -1, &hname) == CURLHE_OK)
319 {
320 response->header = g_strdup (hname->value);
321 }
322 }
323
324 // Cleanup
325 gvm_http_response_cleanup (http_response);
326 g_free (url);
327
328 return response;
329}
330
340{
341 openvasd_resp_t response = NULL;
342 gvm_http_headers_t *customheader = NULL;
343
344 customheader = init_customheader (conn->apikey, FALSE);
345
346 response = openvasd_send_request (conn, HEAD, "/", NULL,
347 customheader, NULL);
348
349 gvm_http_headers_free(customheader);
351 return response;
352}
353
368{
369 GString *path;
370 openvasd_resp_t response = NULL;
371 gvm_http_headers_t *customheader = NULL;
372
373 response = g_malloc0 (sizeof (struct openvasd_response));
374
375 path = g_string_new ("/vts?information=1");
376 gchar *url = g_strdup_printf ("%s:%d%s", conn->server, conn->port, path->str);
377
378 customheader = init_customheader (conn->apikey, FALSE);
379
380 if (!conn->stream_resp) {
381 conn->stream_resp = g_malloc0 (sizeof(struct gvm_http_response_stream));
382 }
383
384 gvm_http_multi_t *multi_handle = gvm_http_multi_new();
385 if (!multi_handle)
386 {
387 g_warning ("%s: Failed to initialize curl multi-handle", __func__);
388 g_string_free (path, TRUE);
389 g_free (url);
390 response->code = RESP_CODE_ERR;
391 response->body = 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 (
397 url, GET, NULL, customheader,
398 conn->ca_cert, conn->cert, conn->key, conn->stream_resp
399 );
400
401 g_string_free (path, TRUE);
402 g_free(url);
403
404 // Check if curl handle was created properly
405 if (!http || !http->handler) {
406 g_warning("%s: Failed to initialize curl request", __func__);
407 gvm_http_headers_free (customheader);
408 gvm_http_multi_free (multi_handle);
409 response->code = RESP_CODE_ERR;
410 response->body = g_strdup("{\"error\": \"Failed to initialize CURL request\"}");
411 return response;
412 }
413
414 gvm_http_multi_result_t multi_add_result = gvm_http_multi_add_handler (multi_handle, http);
415 if (multi_add_result != GVM_HTTP_OK) {
416 g_warning("%s: Failed to add CURL handle to multi", __func__);
417 gvm_http_multi_handler_free (multi_handle, http);
418 gvm_http_headers_free (customheader);
419 gvm_http_multi_free (multi_handle);
420 response->code = RESP_CODE_ERR;
421 response->body = g_strdup ("{\"error\": \"Failed to add CURL handle to multi\"}");
422 return response;
423 }
424
425 conn->stream_resp->multi_handler = multi_handle;
426 conn->stream_resp->multi_handler->headers = customheader;
427
428 g_debug("%s: Multi handle initialized successfully", __func__);
429
430 response->code = RESP_CODE_OK;
431 return response;
432}
433
434void
436{
437 gvm_http_response_stream_reset (conn->stream_resp);
438}
439
440gchar *
442{
443 return conn->stream_resp->data;
444}
445
446size_t
448{
449 return conn->stream_resp->length;
450}
451
463int
465{
466 static int running = 0;
467
468 gvm_http_multi_t *multi = conn->stream_resp->multi_handler;
469 if (!multi || !multi->handler)
470 {
471 g_warning ("%s: Invalid multi-handler", __func__);
472 return -1;
473 }
474
475 gvm_http_multi_result_t mc = gvm_http_multi_perform (multi, &running);
476
477 if (mc == GVM_HTTP_OK && running)
478 {
479 /* wait for activity, timeout, or "nothing" */
480 CURLMcode poll_result = curl_multi_poll (multi->handler, NULL, 0, 5000, NULL);
481 if (poll_result != CURLM_OK)
482 {
483 g_warning ("%s: error on curl_multi_poll(): %d\n", __func__, poll_result);
484 return -1;
485 }
486 }
487
488 return running;
489}
490
501{
502 GString *path;
503 openvasd_resp_t response = NULL;
504 gvm_http_headers_t *customheader = NULL;
505
506 path = g_string_new ("/vts?information=1");
507 customheader = init_customheader (conn->apikey, FALSE);
508 response = openvasd_send_request (conn, GET, path->str, NULL,
509 customheader, NULL);
510
511 g_string_free (path, TRUE);
512
513 gvm_http_headers_free (customheader);
514 if (response->code != RESP_CODE_ERR)
515 response->body = g_strdup (openvasd_vt_stream_str (conn));
516
518 return response;
519}
520
531{
532 openvasd_resp_t response = NULL;
533 cJSON *parser = NULL;
534 GString *path;
535 gvm_http_headers_t *customheader = NULL;
536
537 customheader = init_customheader (conn->apikey, TRUE);
538 response = openvasd_send_request (conn, POST, "/scans", data,
539 customheader, NULL);
540
541 gvm_http_headers_free (customheader);
542
543 if (response->code == RESP_CODE_ERR)
544 {
545 response->code = RESP_CODE_ERR;
546 if (response->body == NULL)
547 response->body =
548 g_strdup ("{\"error\": \"Storing scan configuration\"}");
549 g_warning ("%s: Error storing scan configuration ", __func__);
551 return response;
552 }
553
554 // Get the Scan ID
555 parser = cJSON_Parse (openvasd_vt_stream_str (conn));
556 if (!parser)
557 {
558 const gchar *error_ptr = cJSON_GetErrorPtr ();
559 g_warning ("%s: Error parsing json string to get the scan ID", __func__);
560 if (error_ptr != NULL)
561 {
562 response->body = g_strdup_printf ("{\"error\": \"%s\"}", error_ptr);
563 g_warning ("%s: %s", __func__, error_ptr);
564 }
565 else
566 {
567 response->body = g_strdup (
568 "{\"error\": \"Parsing json string to get the scan ID\"}");
569 }
570 response->code = RESP_CODE_ERR;
571 cJSON_Delete (parser);
573 return response;
574 }
575
576 conn->scan_id = g_strdup (cJSON_GetStringValue (parser));
577
578 // Start the scan
579 path = g_string_new ("/scans");
580 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
581 {
582 g_string_append (path, "/");
583 g_string_append (path, conn->scan_id);
584 }
585 else
586 {
587 response->code = RESP_CODE_ERR;
588 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
589 g_string_free (path, TRUE);
590 g_warning ("%s: Missing scan ID", __func__);
591 cJSON_Delete (parser);
592 return response;
593 }
594
596 customheader = init_customheader (conn->apikey, TRUE);
597 response = openvasd_send_request (conn, POST, path->str,
598 "{\"action\": \"start\"}", customheader,NULL);
599
600 g_string_free (path, TRUE);
601
602 gvm_http_headers_free (customheader);
603 if (response->code == RESP_CODE_ERR)
604 {
605 response->code = RESP_CODE_ERR;
606 if (response->body == NULL)
607 response->body = g_strdup ("{\"error\": \"Starting the scan.\"}");
608 g_warning ("%s: Error starting the scan.", __func__);
609 return response;
610 }
611
612 cJSON_Delete (parser);
613 response->body = g_strdup (openvasd_vt_stream_str (conn));
615 return response;
616}
617
620{
621 openvasd_resp_t response = NULL;
622 GString *path;
623 gvm_http_headers_t *customheader = NULL;
624
625 // Stop the scan
626 path = g_string_new ("/scans");
627 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
628 {
629 g_string_append (path, "/");
630 g_string_append (path, conn->scan_id);
631 }
632 else
633 {
634 response->code = RESP_CODE_ERR;
635 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
636 g_string_free (path, TRUE);
637 g_warning ("%s: Missing scan ID", __func__);
638 return response;
639 }
640
641 customheader = init_customheader (conn->apikey, TRUE);
642 response = openvasd_send_request (conn, POST, path->str,
643 "{\"action\": \"stop\"}",
644 customheader, NULL);
645
646 g_string_free (path, TRUE);
647
648 gvm_http_headers_free (customheader);
649 if (response->code != RESP_CODE_ERR)
650 response->body = g_strdup (openvasd_vt_stream_str (conn));
651
653 return response;
654}
655
658{
659 openvasd_resp_t response = NULL;
660 GString *path = NULL;
661 gvm_http_headers_t *customheader = NULL;
662
663 response = g_malloc0 (sizeof (struct openvasd_response));
664
665 path = g_string_new ("/scans");
666 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
667 {
668 g_string_append (path, "/");
669 g_string_append (path, conn->scan_id);
670 if (last > first)
671 g_string_append_printf (path, "/results?range%ld-%ld", first, last);
672 else if (last < first)
673 g_string_append_printf (path, "/results?range=%ld", first);
674 else
675 g_string_append (path, "/results");
676 }
677 else
678 {
679 response->code = RESP_CODE_ERR;
680 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
681 g_string_free (path, TRUE);
682 g_warning ("%s: Missing scan ID", __func__);
683 return response;
684 }
685
686 customheader = init_customheader (conn->apikey, FALSE);
687 response = openvasd_send_request (conn, GET, path->str,
688 NULL, customheader, NULL);
689 g_string_free (path, TRUE);
690
691 gvm_http_headers_free (customheader);
692 if (response->code != RESP_CODE_ERR)
693 response->body = g_strdup (openvasd_vt_stream_str (conn));
694 else if (response->code == RESP_CODE_ERR)
695 {
696 g_warning ("%s: Not possible to get scan results", __func__);
697 response->body =
698 g_strdup ("{\"error\": \"Not possible to get scan results\"}");
699 }
700
702 return response;
703}
704
706openvasd_result_new (unsigned long id, gchar *type, gchar *ip_address,
707 gchar *hostname, gchar *oid, int port, gchar *protocol,
708 gchar *message, gchar *detail_name, gchar *detail_value,
709 gchar *detail_source_type, gchar *detail_source_name,
710 gchar *detail_source_description)
711{
712 openvasd_result_t result = g_malloc0 (sizeof (struct openvasd_result));
713
714 result->id = id;
715 result->type = g_strdup (type);
716 result->ip_address = g_strdup (ip_address);
717 result->hostname = g_strdup (hostname);
718 result->oid = g_strdup (oid);
719 result->port = port;
720 result->protocol = g_strdup (protocol);
721 result->message = g_strdup (message);
722 result->detail_name = g_strdup (detail_name);
723 result->detail_value = g_strdup (detail_value);
724 result->detail_source_name = g_strdup (detail_source_name);
725 result->detail_source_type = g_strdup (detail_source_type);
726 result->detail_source_description = g_strdup (detail_source_description);
727
728 return result;
729}
730
731char *
734{
735 if (!result)
736 return NULL;
737 switch (member)
738 {
739 case TYPE:
740 return result->type;
741
742 case IP_ADDRESS:
743 return result->ip_address;
744 case HOSTNAME:
745 return result->hostname;
746 case OID:
747 return result->oid;
748 case PROTOCOL:
749 return result->protocol;
750 case MESSAGE:
751 return result->message;
752 case DETAIL_NAME:
753 return result->detail_name;
754 case DETAIL_VALUE:
755 return result->detail_value;
757 return result->detail_source_name;
759 return result->detail_source_type;
761 return result->detail_source_description;
762 default:
763 return NULL;
764 }
765}
766
767int
770{
771 if (!result)
772 return -1;
773
774 switch (member)
775 {
776 case ID:
777 return result->id;
778 case PORT:
779 return result->port;
780 default:
781 return -1;
782 }
783}
784
785void
787{
788 if (result == NULL)
789 return;
790
791 g_free (result->type);
792 g_free (result->ip_address);
793 g_free (result->hostname);
794 g_free (result->oid);
795 g_free (result->protocol);
796 g_free (result->message);
797 g_free (result->detail_name);
798 g_free (result->detail_value);
799 g_free (result->detail_source_name);
800 g_free (result->detail_source_type);
801 g_free (result->detail_source_description);
802 g_free (result);
803 result = NULL;
804}
805
806static int
807parse_results (const gchar *body, GSList **results)
808{
809 cJSON *parser;
810 cJSON *result_obj = NULL;
811 const gchar *err = NULL;
812 openvasd_result_t result = NULL;
813 int ret = -1;
814
815 parser = cJSON_Parse (body);
816 if (parser == NULL)
817 {
818 err = cJSON_GetErrorPtr ();
819 goto res_cleanup;
820 }
821 if (!cJSON_IsArray (parser))
822 {
823 // No results. No information.
824 goto res_cleanup;
825 }
826
827 cJSON_ArrayForEach (result_obj, parser)
828 {
829 cJSON *item;
830 gchar *detail_name = NULL;
831 gchar *detail_value = NULL;
832 gchar *detail_source_type = NULL;
833 gchar *detail_source_name = NULL;
834 gchar *detail_source_description = NULL;
835
836 if (!cJSON_IsObject (result_obj))
837 // error
838 goto res_cleanup;
839
840 item = cJSON_GetObjectItem (result_obj, "detail");
841 if (item != NULL
842 && cJSON_IsObject (item))
843 {
844 cJSON *detail_obj = NULL;
845
846 detail_name = gvm_json_obj_str (item, "name");
847 detail_value = gvm_json_obj_str (item, "value");
848
849 detail_obj = cJSON_GetObjectItem (item, "source");
850 if (detail_obj && cJSON_IsObject (detail_obj))
851 {
852 detail_source_type = gvm_json_obj_str (detail_obj, "type");
853 detail_source_name = gvm_json_obj_str (detail_obj, "name");
854 detail_source_description = gvm_json_obj_str (detail_obj, "description");
855 }
856 }
857
858 result = openvasd_result_new (gvm_json_obj_double (result_obj, "id"),
859 gvm_json_obj_str (result_obj, "type"),
860 gvm_json_obj_str (result_obj, "ip_address"),
861 gvm_json_obj_str (result_obj, "hostname"),
862 gvm_json_obj_str (result_obj, "oid"),
863 gvm_json_obj_int (result_obj, "port"),
864 gvm_json_obj_str (result_obj, "protocol"),
865 gvm_json_obj_str (result_obj, "message"),
866 detail_name, detail_value,
867 detail_source_type, detail_source_name,
868 detail_source_description);
869
870 *results = g_slist_append (*results, result);
871 ret = 200;
872 }
873
874res_cleanup:
875 if (err != NULL)
876 {
877 g_warning ("%s: Unable to parse scan results. Reason: %s", __func__, err);
878 }
879 cJSON_Delete (parser);
880
881 return ret;
882}
883
884int
886 unsigned long last, GSList **results)
887{
888 int ret;
889 openvasd_resp_t resp;
890
891 resp = openvasd_get_scan_results (conn, first, last);
892 if (resp->code == 200)
893 ret = parse_results (resp->body, results);
894 else
895 ret = resp->code;
896
898
899 return ret;
900}
901
904{
905 openvasd_resp_t response = NULL;
906 GString *path = NULL;
907 gvm_http_headers_t *customheader = NULL;
908
909 path = g_string_new ("/scans");
910 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
911 {
912 g_string_append (path, "/");
913 g_string_append (path, conn->scan_id);
914 g_string_append (path, "/status");
915 }
916 else
917 {
918 response->code = RESP_CODE_ERR;
919 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
920 g_string_free (path, TRUE);
921 g_warning ("%s: Missing scan ID", __func__);
922 return response;
923 }
924
925 customheader = init_customheader (conn->apikey, FALSE);
926 response = openvasd_send_request (conn, GET, path->str,
927 NULL, customheader, NULL);
928 g_string_free (path, TRUE);
929
930 gvm_http_headers_free (customheader);
931 if (response->code != RESP_CODE_ERR)
932 response->body = g_strdup (openvasd_vt_stream_str (conn));
933 else if (response->code == RESP_CODE_ERR)
934 {
935 response->body =
936 g_strdup ("{\"error\": \"Not possible to get scan status\"}");
937 g_warning ("%s: Not possible to get scan status", __func__);
938 }
939
941 return response;
942}
943
948static int
949get_member_value_or_fail (cJSON *reader, const gchar *member)
950{
951 int ret;
952
953 if (gvm_json_obj_check_int (reader, member, &ret))
954 return -1;
955
956 return ret;
957}
958
959static int
961 openvasd_resp_t response)
962{
963 cJSON *parser;
964 cJSON *reader = NULL;
965 const gchar *err = NULL;
966 int all = 0, excluded = 0, dead = 0, alive = 0, queued = 0, finished = 0;
967 int running_hosts_progress_sum = 0;
968
969 openvasd_resp_t resp;
970 int progress = -1;
971
972 if (!response && !conn)
973 return -1;
974
975 if (response == NULL)
976 resp = openvasd_get_scan_status (conn);
977 else
978 resp = response;
979
980 if (resp->code == 404)
981 return -2;
982 else if (resp->code != 200)
983 return -1;
984
985 parser = cJSON_Parse (resp->body);
986 if (!parser)
987 {
988 err = cJSON_GetErrorPtr ();
989 goto cleanup;
990 }
991
992 reader = cJSON_GetObjectItem (parser, "host_info");
993 if (reader == NULL)
994 {
995 goto cleanup;
996 }
997 if (!cJSON_IsObject (reader))
998 {
999 // Scan still not started. No information.
1000 progress = 0;
1001 goto cleanup;
1002 }
1003
1004 // read general hosts count
1005 all = get_member_value_or_fail (reader, "all");
1006 excluded = get_member_value_or_fail (reader, "excluded");
1007 dead = get_member_value_or_fail (reader, "dead");
1008 alive = get_member_value_or_fail (reader, "alive");
1009 queued = get_member_value_or_fail (reader, "queued");
1010 finished = get_member_value_or_fail (reader, "finished");
1011
1012 // read progress of single running hosts
1013 cJSON *scanning;
1014 scanning = cJSON_GetObjectItem (reader, "scanning");
1015 if (scanning != NULL
1016 && cJSON_IsObject (scanning))
1017 {
1018 cJSON *host = scanning->child;
1019 while (host)
1020 {
1021 running_hosts_progress_sum += cJSON_GetNumberValue (host);
1022 host = host->next;
1023 }
1024
1025 } // end scanning
1026 // end host_info
1027
1028 if (all < 0 || excluded < 0 || dead < 0 || alive < 0 || queued < 0
1029 || finished < 0)
1030 {
1031 goto cleanup;
1032 }
1033
1034 if ((all + finished - dead) > 0)
1035 progress = (running_hosts_progress_sum + 100 * (alive + finished))
1036 / (all + finished - dead);
1037 else
1038 progress = 100;
1039
1040cleanup:
1041 if (err != NULL)
1042 g_warning ("%s: Unable to parse scan status. Reason: %s", __func__, err);
1043 cJSON_Delete (parser);
1044
1045 return progress;
1046}
1047
1048int
1053
1054static openvasd_status_t
1055get_status_code_from_openvas (const gchar *status_val)
1056{
1058
1059 if (g_strcmp0 (status_val, "stored") == 0)
1060 status_code = OPENVASD_SCAN_STATUS_STORED;
1061 else if (g_strcmp0 (status_val, "requested") == 0)
1062 status_code = OPENVASD_SCAN_STATUS_REQUESTED;
1063 else if (g_strcmp0 (status_val, "running") == 0)
1064 status_code = OPENVASD_SCAN_STATUS_RUNNING;
1065 else if (g_strcmp0 (status_val, "stopped") == 0)
1066 status_code = OPENVASD_SCAN_STATUS_STOPPED;
1067 else if (g_strcmp0 (status_val, "succeeded") == 0)
1068 status_code = OPENVASD_SCAN_STATUS_SUCCEEDED;
1069 else if (g_strcmp0 (status_val, "interrupted") == 0)
1070 status_code = OPENVASD_SCAN_STATUS_FAILED;
1071
1072 return status_code;
1073}
1074
1075static int
1076parse_status (const gchar *body, openvasd_scan_status_t status_info)
1077{
1078 cJSON *parser;
1079 gchar *status_val = NULL;
1081
1082 if (!status_info)
1083 return -1;
1084
1085 parser = cJSON_Parse (body);
1086 if (parser == NULL)
1087 return -1;
1088
1089 if (gvm_json_obj_check_str (parser, "status", &status_val))
1090 {
1091 cJSON_Delete (parser);
1092 return -1;
1093 }
1094
1095 status_code = get_status_code_from_openvas (status_val);
1096
1097 status_info->status = status_code;
1098 status_info->end_time = gvm_json_obj_double (parser, "end_time");
1099 status_info->start_time = gvm_json_obj_double (parser, "start_time");
1100 cJSON_Delete (parser);
1101
1102 return 0;
1103}
1104
1114{
1115 openvasd_resp_t resp = NULL;
1116 int progress = -1;
1118 openvasd_scan_status_t status_info = NULL;
1119
1120 resp = openvasd_get_scan_status (conn);
1121
1122 status_info = g_malloc0 (sizeof (struct openvasd_scan_status));
1123 if (resp->code != 200 || parse_status (resp->body, status_info) == -1)
1124 {
1125 status_info->status = status_code;
1126 status_info->response_code = resp->code;
1128 return status_info;
1129 }
1130
1131 progress = openvasd_get_scan_progress_ext (NULL, resp);
1133 status_info->progress = progress;
1134
1135 return status_info;
1136}
1137
1140{
1141 openvasd_resp_t response = NULL;
1142 GString *path;
1143 gvm_http_headers_t *customheader = NULL;
1144
1145 // Stop the scan
1146 path = g_string_new ("/scans");
1147 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
1148 {
1149 g_string_append (path, "/");
1150 g_string_append (path, conn->scan_id);
1151 }
1152 else
1153 {
1154 response->code = RESP_CODE_ERR;
1155 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
1156 g_string_free (path, TRUE);
1157 g_warning ("%s: Missing scan ID", __func__);
1158 return response;
1159 }
1160
1161 customheader = init_customheader (conn->apikey, FALSE);
1162 response = openvasd_send_request (conn, DELETE, path->str,
1163 NULL, customheader, NULL);
1164
1165 g_string_free (path, TRUE);
1166
1167 gvm_http_headers_free (customheader);
1168 if (response->code != RESP_CODE_ERR)
1169 response->body = g_strdup (openvasd_vt_stream_str (conn));
1170 else if (response->code == RESP_CODE_ERR)
1171 {
1172 response->body =
1173 g_strdup ("{\"error\": \"Not possible to delete scan.\"}");
1174 g_warning ("%s: Not possible to delete scan", __func__);
1175 }
1176
1178 return response;
1179}
1180
1183{
1184 openvasd_resp_t response = NULL;
1185 gvm_http_headers_t *customheader = NULL;
1186
1187 customheader = init_customheader (conn->apikey, FALSE);
1188 response = openvasd_send_request (conn, GET, "/health/alive",
1189 NULL, customheader, NULL);
1190
1191 gvm_http_headers_free (customheader);
1192 if (response->code != RESP_CODE_ERR)
1193 response->body = g_strdup (openvasd_vt_stream_str (conn));
1194 else if (response->code == RESP_CODE_ERR)
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 gvm_http_headers_t *customheader = NULL;
1210
1211 customheader = init_customheader (conn->apikey, FALSE);
1212 response = openvasd_send_request (conn, GET, "/health/ready",
1213 NULL, customheader, "feed-version");
1214
1215 gvm_http_headers_free (customheader);
1216 if (response->code != RESP_CODE_ERR)
1217 response->body = g_strdup (openvasd_vt_stream_str (conn));
1218 else if (response->code == RESP_CODE_ERR)
1219 {
1220 response->body =
1221 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1222 g_warning ("%s: Not possible to get health information", __func__);
1223 }
1224
1226 return response;
1227}
1228
1231{
1232 openvasd_resp_t response = NULL;
1233 gvm_http_headers_t *customheader = NULL;
1234
1235 customheader = init_customheader (conn->apikey, FALSE);
1236 response = openvasd_send_request (conn, GET, "/health/started",
1237 NULL, customheader, NULL);
1238
1239 gvm_http_headers_free (customheader);
1240 if (response->code != RESP_CODE_ERR)
1241 response->body = g_strdup (openvasd_vt_stream_str (conn));
1242 else if (response->code == RESP_CODE_ERR)
1243 {
1244 response->body =
1245 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1246 g_warning ("%s: Not possible to get health information", __func__);
1247 }
1248
1250 return response;
1251}
1252
1255{
1256 openvasd_resp_t response = NULL;
1257 gvm_http_headers_t *customheader = NULL;
1258
1259 customheader = init_customheader (conn->apikey, FALSE);
1260 response = openvasd_send_request (conn, GET, "/scans/preferences",
1261 NULL, customheader, NULL);
1262
1263 gvm_http_headers_free (customheader);
1264 if (response->code != RESP_CODE_ERR)
1265 response->body = g_strdup (openvasd_vt_stream_str (conn));
1266 else if (response->code == RESP_CODE_ERR)
1267 {
1268 response->body =
1269 g_strdup ("{\"error\": \"Not possible to get scans preferences.\"}");
1270 g_warning ("%s: Not possible to get scans_preferences", __func__);
1271 }
1272
1274 return response;
1275}
1276
1282static openvasd_param_t *
1283openvasd_param_new (char *id, gchar *name, gchar *defval, gchar *description,
1284 gchar *type, int mandatory)
1285{
1286 openvasd_param_t *param = g_malloc0 (sizeof (openvasd_param_t));
1287
1288 param->id = id;
1289 param->defval = defval;
1290 param->description = description;
1291 param->name = name;
1292 param->mandatory = mandatory;
1293 param->type = type;
1294 return param;
1295}
1296
1302void
1304{
1305 if (!param)
1306 return;
1307 g_free (param->id);
1308 g_free (param->name);
1309 g_free (param->defval);
1310 g_free (param->description);
1311 g_free (param->type);
1312}
1313
1319char *
1321{
1322 if (!param)
1323 return NULL;
1324
1325 return param->id;
1326}
1327
1333char *
1335{
1336 if (!param)
1337 return NULL;
1338
1339 return param->defval;
1340}
1341
1347char *
1349{
1350 if (!param)
1351 return NULL;
1352
1353 return param->description;
1354}
1355
1361char *
1363{
1364 if (!param)
1365 return NULL;
1366
1367 return param->type;
1368}
1369
1375char *
1377{
1378 if (!param)
1379 return NULL;
1380
1381 return param->defval;
1382}
1383
1389int
1391{
1392 if (!param)
1393 return 0;
1394
1395 return param->mandatory;
1396}
1397
1398int
1400{
1401 openvasd_resp_t resp = NULL;
1402 cJSON *parser;
1403 cJSON *param_obj = NULL;
1404 int err = 0;
1405
1406 resp = openvasd_get_scan_preferences (conn);
1407
1408 if (resp->code != 200)
1409 return -1;
1410
1411 // No results. No information.
1412 parser = cJSON_Parse (resp->body);
1413 if (parser == NULL || !cJSON_IsArray (parser))
1414 {
1415 err = 1;
1416 goto prefs_cleanup;
1417 }
1418
1419 cJSON_ArrayForEach (param_obj, parser)
1420 {
1421 gchar *defval = NULL, *param_type = NULL;
1422 openvasd_param_t *param = NULL;
1423 int val, mandatory = 0;
1424 char buf[6];
1425 cJSON *item = NULL;
1426
1427 item = cJSON_GetObjectItem (param_obj, "default");
1428 if (item != NULL)
1429 {
1430 if (cJSON_IsNumber (item))
1431 {
1432 val = item->valueint;
1433 g_snprintf (buf, sizeof (buf), "%d", val);
1434 defval = g_strdup (buf);
1435 param_type = g_strdup ("integer");
1436 }
1437 else if (cJSON_IsString (item))
1438 {
1439 defval = g_strdup (item->valuestring);
1440 param_type = g_strdup ("string");
1441 }
1442 else if (cJSON_IsBool (item))
1443 {
1444 if (cJSON_IsTrue (item))
1445 defval = g_strdup ("yes");
1446 else
1447 defval = g_strdup ("no");
1448 param_type = g_strdup ("boolean");
1449 }
1450 else
1451 {
1452 g_warning ("%s: Unable to parse scan preferences.", __func__);
1453 g_free (defval);
1454 g_free (param_type);
1455 continue;
1456 }
1457 }
1458
1459 param =
1460 openvasd_param_new (g_strdup (gvm_json_obj_str (param_obj, "id")),
1461 g_strdup (gvm_json_obj_str (param_obj, "name")),
1462 g_strdup (defval),
1463 g_strdup (gvm_json_obj_str (param_obj, "description")),
1464 g_strdup (param_type), mandatory);
1465 g_free (defval);
1466 g_free (param_type);
1467 *params = g_slist_append (*params, param);
1468 }
1469
1470prefs_cleanup:
1472 cJSON_Delete (parser);
1473 if (err)
1474 {
1475 g_warning ("%s: Unable to parse scan preferences.", __func__);
1476 return -1;
1477 }
1478
1479 return 0;
1480}
1481
1482// Scan config builder
1483static void
1484add_port_to_scan_json (gpointer range, gpointer p_array)
1485{
1486 range_t *ports = range;
1487
1488 cJSON *port = cJSON_CreateObject ();
1489 if (ports->type == 1)
1490 cJSON_AddStringToObject (port, "protocol", "udp");
1491 else
1492 cJSON_AddStringToObject (port, "protocol", "tcp");
1493
1494 cJSON *ranges_array = cJSON_CreateArray ();
1495 cJSON *range_obj = cJSON_CreateObject ();
1496 cJSON_AddNumberToObject (range_obj, "start", ports->start);
1497
1498 if (ports->end > ports->start && ports->end < 65535)
1499 cJSON_AddNumberToObject (range_obj, "end", ports->end);
1500 else
1501 cJSON_AddNumberToObject (range_obj, "end", ports->start);
1502 cJSON_AddItemToArray (ranges_array, range_obj);
1503 cJSON_AddItemToObject (port, "range", ranges_array);
1504 cJSON_AddItemToArray ((cJSON *) p_array, port);
1505}
1506
1507static void
1508add_credential_to_scan_json (gpointer credentials, gpointer cred_array)
1509{
1510 GHashTableIter auth_data_iter;
1511 gchar *auth_data_name, *auth_data_value;
1512 cJSON *cred_obj = NULL;
1513
1514 openvasd_credential_t *cred = credentials;
1515
1516 cred_obj = cJSON_CreateObject ();
1517 cJSON_AddStringToObject (cred_obj, "service", cred->service);
1518
1519 if (cred->port)
1520 {
1521 cJSON_AddNumberToObject (cred_obj, "port", atoi (cred->port));
1522 }
1523
1524 cJSON *cred_type_obj = cJSON_CreateObject ();
1525 g_hash_table_iter_init (&auth_data_iter, cred->auth_data);
1526 while (g_hash_table_iter_next (&auth_data_iter, (gpointer *) &auth_data_name,
1527 (gpointer *) &auth_data_value))
1528 cJSON_AddStringToObject (cred_type_obj, auth_data_name, auth_data_value);
1529 cJSON_AddItemToObject (cred_obj, cred->type, cred_type_obj);
1530
1531 cJSON_AddItemToArray ((cJSON *) cred_array, cred_obj);
1532}
1533
1534static void
1535add_scan_preferences_to_scan_json (gpointer key, gpointer val,
1536 gpointer scan_prefs_array)
1537{
1538 cJSON *pref_obj = cJSON_CreateObject ();
1539 cJSON_AddStringToObject (pref_obj, "id", key);
1540 cJSON_AddStringToObject (pref_obj, "value", val);
1541 cJSON_AddItemToArray (scan_prefs_array, pref_obj);
1542}
1543
1544static void
1545add_vts_to_scan_json (gpointer single_vt, gpointer vts_array)
1546{
1547 GHashTableIter vt_data_iter;
1548 gchar *vt_param_id, *vt_param_value;
1549
1550 openvasd_vt_single_t *vt = single_vt;
1551
1552 cJSON *vt_obj = cJSON_CreateObject ();
1553
1554 cJSON_AddStringToObject (vt_obj, "oid", vt->vt_id);
1555
1556 if (g_hash_table_size (vt->vt_values))
1557 {
1558 cJSON *params_array = cJSON_CreateArray ();
1559
1560 g_hash_table_iter_init (&vt_data_iter, vt->vt_values);
1561 while (g_hash_table_iter_next (&vt_data_iter, (gpointer *) &vt_param_id,
1562 (gpointer *) &vt_param_value))
1563 {
1564 cJSON *param_obj = cJSON_CreateObject ();
1565 cJSON_AddNumberToObject (param_obj, "id", atoi (vt_param_id));
1566 cJSON_AddStringToObject (param_obj, "value", vt_param_value);
1567 cJSON_AddItemToArray (params_array, param_obj);
1568 }
1569 cJSON_AddItemToObject (vt_obj, "parameters", params_array);
1570 }
1571 cJSON_AddItemToArray (vts_array, vt_obj);
1572}
1573
1586char *
1588 GHashTable *scan_preferences, GSList *vts)
1589{
1590 cJSON *scan_obj = NULL;
1591 cJSON *target_obj = NULL;
1592 cJSON *hosts_array = NULL;
1593 cJSON *exclude_hosts_array = NULL;
1594 cJSON *finished_hosts_array = NULL;
1595 gchar *json_str = NULL;
1596
1597 /* Build the message in json format to be published. */
1598 scan_obj = cJSON_CreateObject ();
1599
1600 if (target->scan_id && target->scan_id[0] != '\0')
1601 cJSON_AddStringToObject (scan_obj, "scan_id", target->scan_id);
1602
1603 // begin target
1604 target_obj = cJSON_CreateObject ();
1605
1606 // hosts
1607 hosts_array = cJSON_CreateArray ();
1608 gchar **hosts_list = g_strsplit (target->hosts, ",", 0);
1609 for (int i = 0; hosts_list[i] != NULL; i++)
1610 {
1611 cJSON *host_item = NULL;
1612 host_item = cJSON_CreateString (hosts_list[i]);
1613 cJSON_AddItemToArray (hosts_array, host_item);
1614 }
1615 g_strfreev (hosts_list);
1616 cJSON_AddItemToObject (target_obj, "hosts", hosts_array);
1617
1618 // exclude hosts
1619 if (target->exclude_hosts && target->exclude_hosts[0] != '\0')
1620 {
1621 exclude_hosts_array = cJSON_CreateArray ();
1622 gchar **exclude_hosts_list = g_strsplit (target->exclude_hosts, ",", 0);
1623 for (int i = 0; exclude_hosts_list[i] != NULL; i++)
1624 {
1625 cJSON *exclude_host_item = NULL;
1626 exclude_host_item = cJSON_CreateString (exclude_hosts_list[i]);
1627 cJSON_AddItemToArray (exclude_hosts_array, exclude_host_item);
1628 }
1629 g_strfreev (exclude_hosts_list);
1630 cJSON_AddItemToObject (target_obj, "excluded_hosts", exclude_hosts_array);
1631 }
1632
1633 // finished hosts
1634 if (target->finished_hosts && target->finished_hosts[0] != '\0')
1635 {
1636 finished_hosts_array = cJSON_CreateArray ();
1637 gchar **finished_hosts_list = g_strsplit (target->finished_hosts, ",", 0);
1638 for (int i = 0; finished_hosts_list[i] != NULL; i++)
1639 {
1640 cJSON *finished_host_item = NULL;
1641 finished_host_item = cJSON_CreateString (finished_hosts_list[i]);
1642 cJSON_AddItemToArray (finished_hosts_array, finished_host_item);
1643 }
1644 g_strfreev (hosts_list);
1645 cJSON_AddItemToObject (target_obj, "finished_hosts",
1646 finished_hosts_array);
1647 }
1648
1649 // ports
1650 if (target->ports && target->ports[0] != '\0')
1651 {
1652 cJSON *ports_array = cJSON_CreateArray ();
1653 array_t *ports = port_range_ranges (target->ports);
1654 g_ptr_array_foreach (ports, add_port_to_scan_json, ports_array);
1655 array_free (ports);
1656 cJSON_AddItemToObject (target_obj, "ports", ports_array);
1657 }
1658
1659 // credentials
1660 cJSON *credentials = cJSON_CreateArray ();
1661 g_slist_foreach (target->credentials, add_credential_to_scan_json,
1662 credentials);
1663 cJSON_AddItemToObject (target_obj, "credentials", credentials);
1664
1665 // reverse lookup
1666 if (target->reverse_lookup_unify)
1667 cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", cJSON_True);
1668 else
1669 cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", cJSON_False);
1670
1671 if (target->reverse_lookup_only)
1672 cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", cJSON_True);
1673 else
1674 cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", cJSON_False);
1675
1676 // alive test methods
1677 cJSON *alive_test_methods = cJSON_CreateArray ();
1678 if (target->arp)
1679 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("arp"));
1680 if (target->tcp_ack)
1681 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_ack"));
1682 if (target->tcp_syn)
1683 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_syn"));
1684 if (target->consider_alive)
1685 cJSON_AddItemToArray (alive_test_methods,
1686 cJSON_CreateString ("consider_alive"));
1687 if (target->icmp)
1688 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("icmp"));
1689 cJSON_AddItemToObject (target_obj, "alive_test_methods", alive_test_methods);
1690
1691 cJSON_AddItemToObject (scan_obj, "target", target_obj);
1692
1693 // Begin Scan Preferences
1694 cJSON *scan_prefs_array = cJSON_CreateArray ();
1695 g_hash_table_foreach (scan_preferences, add_scan_preferences_to_scan_json,
1696 scan_prefs_array);
1697 cJSON_AddItemToObject (scan_obj, "scan_preferences", scan_prefs_array);
1698
1699 // Begin VTs
1700 cJSON *vts_array = cJSON_CreateArray ();
1701 g_slist_foreach (vts, add_vts_to_scan_json, vts_array);
1702 cJSON_AddItemToObject (scan_obj, "vts", vts_array);
1703
1704 json_str = cJSON_Print (scan_obj);
1705 cJSON_Delete (scan_obj);
1706 if (json_str == NULL)
1707 g_warning ("%s: Error while creating JSON.", __func__);
1708
1709 return json_str;
1710}
1711
1722openvasd_credential_new (const gchar *type, const gchar *service,
1723 const gchar *port)
1724{
1725 openvasd_credential_t *new_credential;
1726
1727 new_credential = g_malloc0 (sizeof (openvasd_credential_t));
1728
1729 new_credential->type = type ? g_strdup (type) : NULL;
1730 new_credential->service = service ? g_strdup (service) : NULL;
1731 new_credential->port = port ? g_strdup (port) : NULL;
1732 new_credential->auth_data =
1733 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1734
1735 return new_credential;
1736}
1737
1743void
1745{
1746 if (!credential)
1747 return;
1748
1749 g_free (credential->type);
1750 g_free (credential->service);
1751 g_free (credential->port);
1752 g_hash_table_destroy (credential->auth_data);
1753 g_free (credential);
1754}
1755
1763void
1765 const gchar *name, const gchar *value)
1766{
1767 if (credential == NULL || name == NULL)
1768 return;
1769
1770 if (g_regex_match_simple ("^[[:alpha:]][[:alnum:]_]*$", name, 0, 0))
1771 {
1772 if (value)
1773 g_hash_table_replace (credential->auth_data, g_strdup (name),
1774 g_strdup (value));
1775 else
1776 g_hash_table_remove (credential->auth_data, name);
1777 }
1778 else
1779 {
1780 g_warning ("%s: Invalid auth data name: %s", __func__, name);
1781 }
1782}
1783
1797openvasd_target_new (const gchar *scanid, const gchar *hosts,
1798 const gchar *ports, const gchar *exclude_hosts,
1799 int reverse_lookup_unify, int reverse_lookup_only)
1800{
1801 openvasd_target_t *new_target;
1802 new_target = g_malloc0 (sizeof (openvasd_target_t));
1803
1804 if (scanid && *scanid)
1805 new_target->scan_id = g_strdup (scanid);
1806
1807 new_target->exclude_hosts = exclude_hosts ? g_strdup (exclude_hosts) : NULL;
1808 new_target->finished_hosts = NULL;
1809 new_target->hosts = hosts ? g_strdup (hosts) : NULL;
1810 new_target->ports = ports ? g_strdup (ports) : NULL;
1811 new_target->reverse_lookup_unify =
1812 reverse_lookup_unify ? reverse_lookup_unify : 0;
1813 new_target->reverse_lookup_only =
1814 reverse_lookup_only ? reverse_lookup_only : 0;
1815
1816 return new_target;
1817}
1818
1825void
1827 const gchar *finished_hosts)
1828{
1829 g_free (target->finished_hosts);
1830 target->finished_hosts = finished_hosts ? g_strdup (finished_hosts) : NULL;
1831}
1832
1838void
1840{
1841 if (!target)
1842 return;
1843
1844 g_slist_free_full (target->credentials,
1845 (GDestroyNotify) openvasd_credential_free);
1846 g_free (target->exclude_hosts);
1847 g_free (target->finished_hosts);
1848 g_free (target->scan_id);
1849 g_free (target->hosts);
1850 g_free (target->ports);
1851 g_free (target);
1852 target = NULL;
1853}
1854
1865void
1867 gboolean icmp, gboolean tcp_syn,
1868 gboolean tcp_ack, gboolean arp,
1869 gboolean consider_alive)
1870{
1871 if (!target)
1872 return;
1873
1874 target->icmp = icmp;
1875 target->tcp_syn = tcp_syn;
1876 target->tcp_ack = tcp_ack;
1877 target->arp = arp;
1878 target->consider_alive = consider_alive;
1879}
1880
1887void
1889 openvasd_credential_t *credential)
1890{
1891 if (!target || !credential)
1892 return;
1893
1894 target->credentials = g_slist_prepend (target->credentials, credential);
1895}
1896
1905openvasd_vt_single_new (const gchar *vt_id)
1906{
1907 openvasd_vt_single_t *new_vt_single;
1908 new_vt_single = g_malloc0 (sizeof (openvasd_vt_single_t));
1909
1910 new_vt_single->vt_id = vt_id ? g_strdup (vt_id) : NULL;
1911 new_vt_single->vt_values =
1912 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1913
1914 return new_vt_single;
1915}
1916
1922void
1924{
1925 if (!vt_single)
1926 return;
1927
1928 g_hash_table_destroy (vt_single->vt_values);
1929
1930 g_free (vt_single->vt_id);
1931 g_free (vt_single);
1932}
1933
1943void
1945 const gchar *name, const gchar *value)
1946{
1947 g_hash_table_replace (vt_single->vt_values, g_strdup (name),
1948 g_strdup (value));
1949}
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:1888
void openvasd_param_free(openvasd_param_t *param)
Free an openvasd parameter.
Definition openvasd.c:1303
#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:1764
static openvasd_resp_t openvasd_send_request(openvasd_connector_t conn, gvm_http_method_t method, const gchar *path, const gchar *data, gvm_http_headers_t *custom_headers, const gchar *header_name)
Sends an HTTP(S) request to the OpenVAS daemon using the specified parameters.
Definition openvasd.c:263
int openvasd_get_result_member_int(openvasd_result_t result, openvasd_result_member_int_t member)
Definition openvasd.c:768
void openvasd_target_free(openvasd_target_t *target)
Free an openvasd target, including all added credentials.
Definition openvasd.c:1839
openvasd_scan_status_t openvasd_parsed_scan_status(openvasd_connector_t conn)
Return a struct with the general scan status.
Definition openvasd.c:1113
char * openvasd_param_desc(openvasd_param_t *param)
Get the parameter description.
Definition openvasd.c:1348
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:706
void openvasd_reset_vt_stream(openvasd_connector_t conn)
Definition openvasd.c:435
void openvasd_credential_free(openvasd_credential_t *credential)
Free an openvasd credential.
Definition openvasd.c:1744
size_t openvasd_vt_stream_len(openvasd_connector_t conn)
Definition openvasd.c:447
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:1722
openvasd_resp_t openvasd_get_scan_results(openvasd_connector_t conn, long first, long last)
Definition openvasd.c:657
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:1587
char * openvasd_param_name(openvasd_param_t *param)
Get the parameter default.
Definition openvasd.c:1334
static void add_credential_to_scan_json(gpointer credentials, gpointer cred_array)
Definition openvasd.c:1508
openvasd_resp_t openvasd_get_scan_preferences(openvasd_connector_t conn)
Definition openvasd.c:1254
int openvasd_parsed_results(openvasd_connector_t conn, unsigned long first, unsigned long last, GSList **results)
Definition openvasd.c:885
int openvasd_param_mandatory(openvasd_param_t *param)
If the parameter is mandatory.
Definition openvasd.c:1390
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:367
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:1797
void openvasd_result_free(openvasd_result_t result)
Definition openvasd.c:786
char * openvasd_get_result_member_str(openvasd_result_t result, openvasd_result_member_string_t member)
Definition openvasd.c:732
#define RESP_CODE_OK
Definition openvasd.c:32
int openvasd_get_scan_progress(openvasd_connector_t conn)
Definition openvasd.c:1049
static void add_port_to_scan_json(gpointer range, gpointer p_array)
Definition openvasd.c:1484
static openvasd_status_t get_status_code_from_openvas(const gchar *status_val)
Definition openvasd.c:1055
char * openvasd_param_type(openvasd_param_t *param)
Get the parameter type.
Definition openvasd.c:1362
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:1182
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:1826
static int get_member_value_or_fail(cJSON *reader, const gchar *member)
Get the value from an object or error.
Definition openvasd.c:949
void openvasd_vt_single_free(openvasd_vt_single_t *vt_single)
Free a single openvasd VT, including all preference values.
Definition openvasd.c:1923
openvasd_resp_t openvasd_get_version(openvasd_connector_t conn)
Request HEAD.
Definition openvasd.c:339
char * openvasd_param_default(openvasd_param_t *param)
Get the parameter default.
Definition openvasd.c:1376
static void add_scan_preferences_to_scan_json(gpointer key, gpointer val, gpointer scan_prefs_array)
Definition openvasd.c:1535
openvasd_resp_t openvasd_get_vts(openvasd_connector_t conn)
Get VT's metadata.
Definition openvasd.c:500
int openvasd_get_vt_stream(openvasd_connector_t conn)
Get a new feed metadata chunk.
Definition openvasd.c:464
openvasd_resp_t openvasd_start_scan(openvasd_connector_t conn, gchar *data)
Definition openvasd.c:530
static void add_vts_to_scan_json(gpointer single_vt, gpointer vts_array)
Definition openvasd.c:1545
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:1944
static int parse_status(const gchar *body, openvasd_scan_status_t status_info)
Definition openvasd.c:1076
openvasd_resp_t openvasd_get_health_started(openvasd_connector_t conn)
Definition openvasd.c:1230
openvasd_error_t openvasd_connector_free(openvasd_connector_t conn)
Build a openvasd connector.
Definition openvasd.c:185
openvasd_resp_t openvasd_delete_scan(openvasd_connector_t conn)
Definition openvasd.c:1139
void openvasd_response_cleanup(openvasd_resp_t resp)
Free an openvasd response struct.
Definition openvasd.c:210
static int openvasd_get_scan_progress_ext(openvasd_connector_t conn, openvasd_resp_t response)
Definition openvasd.c:960
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:1866
gchar * openvasd_vt_stream_str(openvasd_connector_t conn)
Definition openvasd.c:441
openvasd_resp_t openvasd_stop_scan(openvasd_connector_t conn)
Definition openvasd.c:619
openvasd_resp_t openvasd_get_health_ready(openvasd_connector_t conn)
Definition openvasd.c:1206
static gvm_http_headers_t * init_customheader(const gchar *apikey, gboolean contenttype)
Definition openvasd.c:222
char * openvasd_param_id(openvasd_param_t *param)
Get the parameter id.
Definition openvasd.c:1320
static int parse_results(const gchar *body, GSList **results)
Definition openvasd.c:807
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:1283
int openvasd_parsed_scans_preferences(openvasd_connector_t conn, GSList **params)
Definition openvasd.c:1399
openvasd_vt_single_t * openvasd_vt_single_new(const gchar *vt_id)
Create a new single openvasd VT.
Definition openvasd.c:1905
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:903
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:38
gchar * apikey
Definition openvasd.c:42
gchar * server
Definition openvasd.c:43
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:46
gchar * ca_cert
Definition openvasd.c:39
gchar * scan_id
Definition openvasd.c:45
gchar * host
Definition openvasd.c:44
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
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:98
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
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