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