Greenbone Vulnerability Management Libraries 22.20.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
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 const gchar *header_name)
267{
268 openvasd_resp_t response = g_malloc0 (sizeof (struct openvasd_response));
269 response->code = RESP_CODE_ERR;
270 response->body = NULL;
271 response->header = NULL;
272
273 if (!conn)
274 {
275 g_warning ("openvasd_send_request_test: Invalid connector");
276 response->body = g_strdup ("{\"error\": \"Missing openvasd connector\"}");
277 return response;
278 }
279
280 gchar *url = g_strdup_printf ("%s:%d%s", conn->server, conn->port, path);
281
282 if (!conn->stream_resp)
283 {
284 conn->stream_resp = g_malloc0 (sizeof (struct gvm_http_response_stream));
285 }
286
287 gvm_http_headers_t *custom_headers = init_customheader (conn->apikey,
288 data ? TRUE : FALSE);
289
290 // Send request
291 gvm_http_response_t *http_response = gvm_http_request (url, method,
292 data,
293 custom_headers,
294 conn->ca_cert,
295 conn->cert,
296 conn->key,
297 conn->stream_resp);
298
299 // Check for request errors
300 if (http_response->http_status == -1)
301 {
302 g_warning ("%s: Error performing CURL request", __func__);
303 response->body = g_strdup ("{\"error\": \"Error sending request\"}");
304 gvm_http_response_cleanup (http_response);
305 g_free (url);
306 gvm_http_headers_free (custom_headers);
307 return response;
308 }
309
310 // Populate response struct
311 response->code = (int) http_response->http_status;
312 response->body = g_strdup (http_response->data ? http_response->data :
313 "{\"error\": \"No response\"}");
314
315 // Extract specific header if requested
316 if (header_name)
317 {
318 struct curl_header *hname;
319 if (curl_easy_header (http_response->http->handler, header_name, 0,
320 CURLH_HEADER, -1, &hname) == CURLHE_OK)
321 {
322 response->header = g_strdup (hname->value);
323 }
324 }
325
326 // Cleanup
327 gvm_http_response_cleanup (http_response);
328 g_free (url);
329 gvm_http_headers_free (custom_headers);
330
331 return response;
332}
333
343{
344 openvasd_resp_t response = NULL;
345
346 response = openvasd_send_request (conn, HEAD, "/", NULL, NULL);
347
349 return response;
350}
351
366{
367 GString *path;
368 openvasd_resp_t response = NULL;
369 gvm_http_headers_t *customheader = NULL;
370
371 response = g_malloc0 (sizeof (struct openvasd_response));
372
373 path = g_string_new ("/vts?information=1");
374 gchar *url = g_strdup_printf ("%s:%d%s", conn->server, conn->port, path->str);
375
376 customheader = init_customheader (conn->apikey, FALSE);
377
378 if (!conn->stream_resp) {
379 conn->stream_resp = g_malloc0 (sizeof(struct gvm_http_response_stream));
380 }
381
382 gvm_http_multi_t *multi_handle = gvm_http_multi_new();
383 if (!multi_handle)
384 {
385 g_warning ("%s: Failed to initialize curl multi-handle", __func__);
386 g_string_free (path, TRUE);
387 g_free (url);
388 response->code = RESP_CODE_ERR;
389 response->body = g_strdup ("{\"error\": \"Failed to initialize multi-handle\"}");
390 return response;
391 }
392
393 // Initialize request using curlutils
394 gvm_http_t *http = gvm_http_new (
395 url, GET, NULL, customheader,
396 conn->ca_cert, conn->cert, conn->key, conn->stream_resp
397 );
398
399 g_string_free (path, TRUE);
400 g_free(url);
401
402 // Check if curl handle was created properly
403 if (!http || !http->handler) {
404 g_warning("%s: Failed to initialize curl request", __func__);
405 gvm_http_headers_free (customheader);
406 gvm_http_multi_free (multi_handle);
407 response->code = RESP_CODE_ERR;
408 response->body = g_strdup("{\"error\": \"Failed to initialize CURL request\"}");
409 return response;
410 }
411
412 gvm_http_multi_result_t multi_add_result = gvm_http_multi_add_handler (multi_handle, http);
413 if (multi_add_result != GVM_HTTP_OK) {
414 g_warning("%s: Failed to add CURL handle to multi", __func__);
415 gvm_http_multi_handler_free (multi_handle, http);
416 gvm_http_headers_free (customheader);
417 gvm_http_multi_free (multi_handle);
418 response->code = RESP_CODE_ERR;
419 response->body = g_strdup ("{\"error\": \"Failed to add CURL handle to multi\"}");
420 return response;
421 }
422
423 conn->stream_resp->multi_handler = multi_handle;
424 conn->stream_resp->multi_handler->headers = customheader;
425
426 g_debug("%s: Multi handle initialized successfully", __func__);
427
428 response->code = RESP_CODE_OK;
429 return response;
430}
431
432void
434{
435 gvm_http_response_stream_reset (conn->stream_resp);
436}
437
438gchar *
440{
441 return conn->stream_resp->data;
442}
443
444size_t
446{
447 return conn->stream_resp->length;
448}
449
461int
463{
464 static int running = 0;
465
466 gvm_http_multi_t *multi = conn->stream_resp->multi_handler;
467 if (!multi || !multi->handler)
468 {
469 g_warning ("%s: Invalid multi-handler", __func__);
470 return -1;
471 }
472
473 gvm_http_multi_result_t mc = gvm_http_multi_perform (multi, &running);
474
475 if (mc == GVM_HTTP_OK && running)
476 {
477 /* wait for activity, timeout, or "nothing" */
478 CURLMcode poll_result = curl_multi_poll (multi->handler, NULL, 0, 5000, NULL);
479 if (poll_result != CURLM_OK)
480 {
481 g_warning ("%s: error on curl_multi_poll(): %d\n", __func__, poll_result);
482 return -1;
483 }
484 }
485
486 return running;
487}
488
499{
500 GString *path;
501 openvasd_resp_t response = NULL;
502
503 path = g_string_new ("/vts?information=1");
504 response = openvasd_send_request (conn, GET, path->str, NULL, NULL);
505
506 g_string_free (path, TRUE);
507
508 if (response->code != RESP_CODE_ERR)
509 response->body = g_strdup (openvasd_vt_stream_str (conn));
510
512 return response;
513}
514
525{
526 openvasd_resp_t response = NULL;
527 cJSON *parser = NULL;
528 GString *path;
529
530 response = openvasd_send_request (conn, POST, "/scans", data, NULL);
531
532 if (response->code == RESP_CODE_ERR)
533 {
534 response->code = RESP_CODE_ERR;
535 if (response->body == NULL)
536 response->body =
537 g_strdup ("{\"error\": \"Storing scan configuration\"}");
538 g_warning ("%s: Error storing scan configuration ", __func__);
540 return response;
541 }
542
543 // Get the Scan ID
544 parser = cJSON_Parse (openvasd_vt_stream_str (conn));
545 if (!parser)
546 {
547 const gchar *error_ptr = cJSON_GetErrorPtr ();
548 g_warning ("%s: Error parsing json string to get the scan ID", __func__);
549 if (error_ptr != NULL)
550 {
551 response->body = g_strdup_printf ("{\"error\": \"%s\"}", error_ptr);
552 g_warning ("%s: %s", __func__, error_ptr);
553 }
554 else
555 {
556 response->body = g_strdup (
557 "{\"error\": \"Parsing json string to get the scan ID\"}");
558 }
559 response->code = RESP_CODE_ERR;
560 cJSON_Delete (parser);
562 return response;
563 }
564
565 conn->scan_id = g_strdup (cJSON_GetStringValue (parser));
566
567 // Start the scan
568 path = g_string_new ("/scans");
569 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
570 {
571 g_string_append (path, "/");
572 g_string_append (path, conn->scan_id);
573 }
574 else
575 {
576 response->code = RESP_CODE_ERR;
577 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
578 g_string_free (path, TRUE);
579 g_warning ("%s: Missing scan ID", __func__);
580 cJSON_Delete (parser);
581 return response;
582 }
583
585 response = openvasd_send_request (conn, POST, path->str,
586 "{\"action\": \"start\"}", NULL);
587
588 g_string_free (path, TRUE);
589
590 if (response->code == RESP_CODE_ERR)
591 {
592 response->code = RESP_CODE_ERR;
593 if (response->body == NULL)
594 response->body = g_strdup ("{\"error\": \"Starting the scan.\"}");
595 g_warning ("%s: Error starting the scan.", __func__);
596 return response;
597 }
598
599 cJSON_Delete (parser);
600 response->body = g_strdup (openvasd_vt_stream_str (conn));
602 return response;
603}
604
607{
608 openvasd_resp_t response = NULL;
609 GString *path;
610
611 // Stop the scan
612 path = g_string_new ("/scans");
613 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
614 {
615 g_string_append (path, "/");
616 g_string_append (path, conn->scan_id);
617 }
618 else
619 {
620 response->code = RESP_CODE_ERR;
621 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
622 g_string_free (path, TRUE);
623 g_warning ("%s: Missing scan ID", __func__);
624 return response;
625 }
626
627 response = openvasd_send_request (conn, POST, path->str,
628 "{\"action\": \"stop\"}", NULL);
629
630 g_string_free (path, TRUE);
631
632 if (response->code != RESP_CODE_ERR)
633 response->body = g_strdup (openvasd_vt_stream_str (conn));
634
636 return response;
637}
638
641{
642 openvasd_resp_t response = NULL;
643 GString *path = NULL;
644
645 response = g_malloc0 (sizeof (struct openvasd_response));
646
647 path = g_string_new ("/scans");
648 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
649 {
650 g_string_append (path, "/");
651 g_string_append (path, conn->scan_id);
652 if (last > first)
653 g_string_append_printf (path, "/results?range%ld-%ld", first, last);
654 else if (last < first)
655 g_string_append_printf (path, "/results?range=%ld", first);
656 else
657 g_string_append (path, "/results");
658 }
659 else
660 {
661 response->code = RESP_CODE_ERR;
662 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
663 g_string_free (path, TRUE);
664 g_warning ("%s: Missing scan ID", __func__);
665 return response;
666 }
667
668 response = openvasd_send_request (conn, GET, path->str, NULL, NULL);
669 g_string_free (path, TRUE);
670
671 if (response->code != RESP_CODE_ERR)
672 response->body = g_strdup (openvasd_vt_stream_str (conn));
673 else if (response->code == RESP_CODE_ERR)
674 {
675 g_warning ("%s: Not possible to get scan results", __func__);
676 response->body =
677 g_strdup ("{\"error\": \"Not possible to get scan results\"}");
678 }
679
681 return response;
682}
683
685openvasd_result_new (unsigned long id, gchar *type, gchar *ip_address,
686 gchar *hostname, gchar *oid, int port, gchar *protocol,
687 gchar *message, gchar *detail_name, gchar *detail_value,
688 gchar *detail_source_type, gchar *detail_source_name,
689 gchar *detail_source_description)
690{
691 openvasd_result_t result = g_malloc0 (sizeof (struct openvasd_result));
692
693 result->id = id;
694 result->type = g_strdup (type);
695 result->ip_address = g_strdup (ip_address);
696 result->hostname = g_strdup (hostname);
697 result->oid = g_strdup (oid);
698 result->port = port;
699 result->protocol = g_strdup (protocol);
700 result->message = g_strdup (message);
701 result->detail_name = g_strdup (detail_name);
702 result->detail_value = g_strdup (detail_value);
703 result->detail_source_name = g_strdup (detail_source_name);
704 result->detail_source_type = g_strdup (detail_source_type);
705 result->detail_source_description = g_strdup (detail_source_description);
706
707 return result;
708}
709
710char *
713{
714 if (!result)
715 return NULL;
716 switch (member)
717 {
718 case TYPE:
719 return result->type;
720
721 case IP_ADDRESS:
722 return result->ip_address;
723 case HOSTNAME:
724 return result->hostname;
725 case OID:
726 return result->oid;
727 case PROTOCOL:
728 return result->protocol;
729 case MESSAGE:
730 return result->message;
731 case DETAIL_NAME:
732 return result->detail_name;
733 case DETAIL_VALUE:
734 return result->detail_value;
736 return result->detail_source_name;
738 return result->detail_source_type;
740 return result->detail_source_description;
741 default:
742 return NULL;
743 }
744}
745
746int
749{
750 if (!result)
751 return -1;
752
753 switch (member)
754 {
755 case ID:
756 return result->id;
757 case PORT:
758 return result->port;
759 default:
760 return -1;
761 }
762}
763
764void
766{
767 if (result == NULL)
768 return;
769
770 g_free (result->type);
771 g_free (result->ip_address);
772 g_free (result->hostname);
773 g_free (result->oid);
774 g_free (result->protocol);
775 g_free (result->message);
776 g_free (result->detail_name);
777 g_free (result->detail_value);
778 g_free (result->detail_source_name);
779 g_free (result->detail_source_type);
780 g_free (result->detail_source_description);
781 g_free (result);
782 result = NULL;
783}
784
785static int
786parse_results (const gchar *body, GSList **results)
787{
788 cJSON *parser;
789 cJSON *result_obj = NULL;
790 const gchar *err = NULL;
791 openvasd_result_t result = NULL;
792 int ret = -1;
793
794 parser = cJSON_Parse (body);
795 if (parser == NULL)
796 {
797 err = cJSON_GetErrorPtr ();
798 goto res_cleanup;
799 }
800 if (!cJSON_IsArray (parser))
801 {
802 // No results. No information.
803 goto res_cleanup;
804 }
805
806 cJSON_ArrayForEach (result_obj, parser)
807 {
808 cJSON *item;
809 gchar *detail_name = NULL;
810 gchar *detail_value = NULL;
811 gchar *detail_source_type = NULL;
812 gchar *detail_source_name = NULL;
813 gchar *detail_source_description = NULL;
814
815 if (!cJSON_IsObject (result_obj))
816 // error
817 goto res_cleanup;
818
819 item = cJSON_GetObjectItem (result_obj, "detail");
820 if (item != NULL && cJSON_IsObject (item))
821 {
822 cJSON *detail_obj = NULL;
823
824 detail_name = gvm_json_obj_str (item, "name");
825 detail_value = gvm_json_obj_str (item, "value");
826
827 detail_obj = cJSON_GetObjectItem (item, "source");
828 if (detail_obj && cJSON_IsObject (detail_obj))
829 {
830 detail_source_type = gvm_json_obj_str (detail_obj, "type");
831 detail_source_name = gvm_json_obj_str (detail_obj, "name");
832 detail_source_description =
833 gvm_json_obj_str (detail_obj, "description");
834 }
835 }
836
837 result = openvasd_result_new (
838 gvm_json_obj_double (result_obj, "id"),
839 gvm_json_obj_str (result_obj, "type"),
840 gvm_json_obj_str (result_obj, "ip_address"),
841 gvm_json_obj_str (result_obj, "hostname"),
842 gvm_json_obj_str (result_obj, "oid"),
843 gvm_json_obj_int (result_obj, "port"),
844 gvm_json_obj_str (result_obj, "protocol"),
845 gvm_json_obj_str (result_obj, "message"), detail_name, detail_value,
846 detail_source_type, detail_source_name, detail_source_description);
847
848 *results = g_slist_append (*results, result);
849 ret = 200;
850 }
851
852res_cleanup:
853 if (err != NULL)
854 {
855 g_warning ("%s: Unable to parse scan results. Reason: %s", __func__, err);
856 }
857 cJSON_Delete (parser);
858
859 return ret;
860}
861
862int
864 unsigned long last, GSList **results)
865{
866 int ret;
867 openvasd_resp_t resp;
868
869 resp = openvasd_get_scan_results (conn, first, last);
870 if (resp->code == 200)
871 ret = parse_results (resp->body, results);
872 else
873 ret = resp->code;
874
876
877 return ret;
878}
879
882{
883 openvasd_resp_t response;
884 GString *path = NULL;
885
886 path = g_string_new ("/scans");
887 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
888 {
889 g_string_append (path, "/");
890 g_string_append (path, conn->scan_id);
891 g_string_append (path, "/status");
892 }
893 else
894 {
895 response = g_malloc0 (sizeof (struct openvasd_response));
896 response->code = RESP_CODE_ERR;
897 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
898 g_string_free (path, TRUE);
899 g_warning ("%s: Missing scan ID", __func__);
900 return response;
901 }
902
903 response = openvasd_send_request (conn, GET, path->str, NULL, NULL);
904 g_string_free (path, TRUE);
905
906 if (response->code != RESP_CODE_ERR)
907 response->body = g_strdup (openvasd_vt_stream_str (conn));
908 else if (response->code == RESP_CODE_ERR)
909 {
910 response->body =
911 g_strdup ("{\"error\": \"Not possible to get scan status\"}");
912 g_warning ("%s: Not possible to get scan status", __func__);
913 }
914
916 return response;
917}
918
923static int
924get_member_value_or_fail (cJSON *reader, const gchar *member)
925{
926 int ret;
927
928 if (gvm_json_obj_check_int (reader, member, &ret))
929 return -1;
930
931 return ret;
932}
933
934static int
936 openvasd_resp_t response)
937{
938 cJSON *parser;
939 cJSON *reader = NULL;
940 const gchar *err = NULL;
941 int all = 0, excluded = 0, dead = 0, alive = 0, queued = 0, finished = 0;
942 int running_hosts_progress_sum = 0;
943
944 openvasd_resp_t resp;
945 int progress = -1;
946
947 if (!response && !conn)
948 return -1;
949
950 if (response == NULL)
951 resp = openvasd_get_scan_status (conn);
952 else
953 resp = response;
954
955 if (resp->code == 404)
956 return -2;
957 else if (resp->code != 200)
958 return -1;
959
960 parser = cJSON_Parse (resp->body);
961 if (!parser)
962 {
963 err = cJSON_GetErrorPtr ();
964 goto cleanup;
965 }
966
967 reader = cJSON_GetObjectItem (parser, "host_info");
968 if (reader == NULL)
969 {
970 goto cleanup;
971 }
972 if (!cJSON_IsObject (reader))
973 {
974 // Scan still not started. No information.
975 progress = 0;
976 goto cleanup;
977 }
978
979 // read general hosts count
980 all = get_member_value_or_fail (reader, "all");
981 excluded = get_member_value_or_fail (reader, "excluded");
982 dead = get_member_value_or_fail (reader, "dead");
983 alive = get_member_value_or_fail (reader, "alive");
984 queued = get_member_value_or_fail (reader, "queued");
985 finished = get_member_value_or_fail (reader, "finished");
986
987 // read progress of single running hosts
988 cJSON *scanning;
989 scanning = cJSON_GetObjectItem (reader, "scanning");
990 if (scanning != NULL && cJSON_IsObject (scanning))
991 {
992 cJSON *host = scanning->child;
993 while (host)
994 {
995 running_hosts_progress_sum += cJSON_GetNumberValue (host);
996 host = host->next;
997 }
998
999 } // end scanning
1000 // end host_info
1001
1002 if (all < 0 || excluded < 0 || dead < 0 || alive < 0 || queued < 0
1003 || finished < 0)
1004 {
1005 goto cleanup;
1006 }
1007
1008 if ((all + finished - dead) > 0)
1009 progress = (running_hosts_progress_sum + 100 * (alive + finished))
1010 / (all + finished - dead);
1011 else
1012 progress = 100;
1013
1014cleanup:
1015 if (err != NULL)
1016 g_warning ("%s: Unable to parse scan status. Reason: %s", __func__, err);
1017 cJSON_Delete (parser);
1018
1019 return progress;
1020}
1021
1022int
1027
1028static openvasd_status_t
1029get_status_code_from_openvas (const gchar *status_val)
1030{
1032
1033 if (g_strcmp0 (status_val, "stored") == 0)
1034 status_code = OPENVASD_SCAN_STATUS_STORED;
1035 else if (g_strcmp0 (status_val, "requested") == 0)
1036 status_code = OPENVASD_SCAN_STATUS_REQUESTED;
1037 else if (g_strcmp0 (status_val, "running") == 0)
1038 status_code = OPENVASD_SCAN_STATUS_RUNNING;
1039 else if (g_strcmp0 (status_val, "stopped") == 0)
1040 status_code = OPENVASD_SCAN_STATUS_STOPPED;
1041 else if (g_strcmp0 (status_val, "succeeded") == 0)
1042 status_code = OPENVASD_SCAN_STATUS_SUCCEEDED;
1043 else if (g_strcmp0 (status_val, "interrupted") == 0)
1044 status_code = OPENVASD_SCAN_STATUS_FAILED;
1045
1046 return status_code;
1047}
1048
1049static int
1050parse_status (const gchar *body, openvasd_scan_status_t status_info)
1051{
1052 cJSON *parser;
1053 gchar *status_val = NULL;
1055
1056 if (!status_info)
1057 return -1;
1058
1059 parser = cJSON_Parse (body);
1060 if (parser == NULL)
1061 return -1;
1062
1063 if (gvm_json_obj_check_str (parser, "status", &status_val))
1064 {
1065 cJSON_Delete (parser);
1066 return -1;
1067 }
1068
1069 status_code = get_status_code_from_openvas (status_val);
1070
1071 status_info->status = status_code;
1072 status_info->end_time = gvm_json_obj_double (parser, "end_time");
1073 status_info->start_time = gvm_json_obj_double (parser, "start_time");
1074 cJSON_Delete (parser);
1075
1076 return 0;
1077}
1078
1088{
1089 openvasd_resp_t resp = NULL;
1090 int progress = -1;
1092 openvasd_scan_status_t status_info = NULL;
1093
1094 resp = openvasd_get_scan_status (conn);
1095
1096 status_info = g_malloc0 (sizeof (struct openvasd_scan_status));
1097 if (resp->code != 200 || parse_status (resp->body, status_info) == -1)
1098 {
1099 status_info->status = status_code;
1100 status_info->response_code = resp->code;
1102 return status_info;
1103 }
1104
1105 progress = openvasd_get_scan_progress_ext (NULL, resp);
1107 status_info->progress = progress;
1108
1109 return status_info;
1110}
1111
1114{
1115 openvasd_resp_t response = NULL;
1116 GString *path;
1117
1118 // Stop the scan
1119 path = g_string_new ("/scans");
1120 if (conn->scan_id != NULL && conn->scan_id[0] != '\0')
1121 {
1122 g_string_append (path, "/");
1123 g_string_append (path, conn->scan_id);
1124 }
1125 else
1126 {
1127 response->code = RESP_CODE_ERR;
1128 response->body = g_strdup ("{\"error\": \"Missing scan ID\"}");
1129 g_string_free (path, TRUE);
1130 g_warning ("%s: Missing scan ID", __func__);
1131 return response;
1132 }
1133
1134 response = openvasd_send_request (conn, DELETE, path->str, NULL, NULL);
1135
1136 g_string_free (path, TRUE);
1137
1138 if (response->code != RESP_CODE_ERR)
1139 response->body = g_strdup (openvasd_vt_stream_str (conn));
1140 else if (response->code == RESP_CODE_ERR)
1141 {
1142 response->body =
1143 g_strdup ("{\"error\": \"Not possible to delete scan.\"}");
1144 g_warning ("%s: Not possible to delete scan", __func__);
1145 }
1146
1148 return response;
1149}
1150
1153{
1154 openvasd_resp_t response = NULL;
1155
1156 response = openvasd_send_request (conn, GET, "/health/alive", NULL, NULL);
1157
1158 if (response->code != RESP_CODE_ERR)
1159 response->body = g_strdup (openvasd_vt_stream_str (conn));
1160 else if (response->code == RESP_CODE_ERR)
1161 {
1162 response->body =
1163 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1164 g_warning ("%s: Not possible to get health information", __func__);
1165 }
1166
1168 return response;
1169}
1170
1173{
1174 openvasd_resp_t response = NULL;
1175
1176 response = openvasd_send_request (conn, GET, "/health/ready",
1177 NULL, "feed-version");
1178
1179 if (response->code != RESP_CODE_ERR)
1180 response->body = g_strdup (openvasd_vt_stream_str (conn));
1181 else if (response->code == RESP_CODE_ERR)
1182 {
1183 response->body =
1184 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1185 g_warning ("%s: Not possible to get health information", __func__);
1186 }
1187
1189 return response;
1190}
1191
1194{
1195 openvasd_resp_t response = NULL;
1196
1197 response = openvasd_send_request (conn, GET, "/health/started", NULL, NULL);
1198
1199 if (response->code != RESP_CODE_ERR)
1200 response->body = g_strdup (openvasd_vt_stream_str (conn));
1201 else if (response->code == RESP_CODE_ERR)
1202 {
1203 response->body =
1204 g_strdup ("{\"error\": \"Not possible to get health information.\"}");
1205 g_warning ("%s: Not possible to get health information", __func__);
1206 }
1207
1209 return response;
1210}
1211
1215{
1216 openvasd_resp_t response;
1217 gchar *query;
1218 time_t now;
1219
1220 time (&now);
1221
1222 response = g_malloc0 (sizeof (struct openvasd_response));
1223
1224 if (!opts.titles || !strcmp (opts.titles, "") || opts.start < 0
1225 || opts.start > now || opts.end < 0 || opts.end > now)
1226 {
1227 response->code = RESP_CODE_ERR;
1228 response->body =
1229 g_strdup ("{\"error\": \"Couldn't send get_performance command "
1230 "to scanner. Bad or missing parameters.\"}");
1231 return response;
1232 }
1233
1234 query = g_strdup_printf ("/health/performance?start=%d&end=%d&titles=%s",
1235 opts.start, opts.end, opts.titles);
1236 response = openvasd_send_request (conn, GET, query, NULL, NULL);
1237 g_free (query);
1238
1239 if (response->code != RESP_CODE_ERR)
1240 response->body = g_strdup (openvasd_vt_stream_str (conn));
1241 else
1242 {
1243 response->body = g_strdup (
1244 "{\"error\": \"Not possible to get performance information.\"}");
1245 g_warning ("%s: Not possible to get performance information", __func__);
1246 }
1247
1249 return response;
1250}
1251
1252int
1255 gchar **graph, gchar **err)
1256{
1257 openvasd_resp_t resp = NULL;
1258 cJSON *parser;
1259 cJSON *item;
1260 int ret = 0;
1261 resp = openvasd_get_performance (conn, opts);
1262
1263 // No results. No information.
1264 parser = cJSON_Parse (resp->body);
1265 if (parser == NULL)
1266 {
1267 *err = g_strdup ("Unable to parse sensor performance data");
1268 ret = -1;
1269 }
1270 else if (resp->code != 200)
1271 {
1272 parser = cJSON_Parse (resp->body);
1273 item = cJSON_GetObjectItem (parser, "error");
1274 if (item != NULL)
1275 *err = g_strdup (cJSON_GetStringValue (item));
1276 ret = -1;
1277 }
1278 else
1279 {
1280 item = cJSON_GetArrayItem (parser, 0);
1281 if (item != NULL)
1282 *graph = g_strdup (cJSON_GetStringValue (item));
1283 }
1284
1286 cJSON_Delete (parser);
1287
1288 return ret;
1289}
1290
1293{
1294 openvasd_resp_t response = NULL;
1295
1296 response = openvasd_send_request (conn, GET, "/scans/preferences", NULL,
1297 NULL);
1298
1299 if (response->code != RESP_CODE_ERR)
1300 response->body = g_strdup (openvasd_vt_stream_str (conn));
1301 else if (response->code == RESP_CODE_ERR)
1302 {
1303 response->body =
1304 g_strdup ("{\"error\": \"Not possible to get scans preferences.\"}");
1305 g_warning ("%s: Not possible to get scans_preferences", __func__);
1306 }
1307
1309 return response;
1310}
1311
1317static openvasd_param_t *
1318openvasd_param_new (char *id, gchar *name, gchar *defval, gchar *description,
1319 gchar *type, int mandatory)
1320{
1321 openvasd_param_t *param = g_malloc0 (sizeof (openvasd_param_t));
1322
1323 param->id = id;
1324 param->defval = defval;
1325 param->description = description;
1326 param->name = name;
1327 param->mandatory = mandatory;
1328 param->type = type;
1329 return param;
1330}
1331
1337void
1339{
1340 if (!param)
1341 return;
1342 g_free (param->id);
1343 g_free (param->name);
1344 g_free (param->defval);
1345 g_free (param->description);
1346 g_free (param->type);
1347}
1348
1354char *
1356{
1357 if (!param)
1358 return NULL;
1359
1360 return param->id;
1361}
1362
1368char *
1370{
1371 if (!param)
1372 return NULL;
1373
1374 return param->defval;
1375}
1376
1382char *
1384{
1385 if (!param)
1386 return NULL;
1387
1388 return param->description;
1389}
1390
1396char *
1398{
1399 if (!param)
1400 return NULL;
1401
1402 return param->type;
1403}
1404
1410char *
1412{
1413 if (!param)
1414 return NULL;
1415
1416 return param->defval;
1417}
1418
1424int
1426{
1427 if (!param)
1428 return 0;
1429
1430 return param->mandatory;
1431}
1432
1433int
1435{
1436 openvasd_resp_t resp = NULL;
1437 cJSON *parser;
1438 cJSON *param_obj = NULL;
1439 int err = 0;
1440
1441 resp = openvasd_get_scan_preferences (conn);
1442
1443 if (resp->code != 200)
1444 return -1;
1445
1446 // No results. No information.
1447 parser = cJSON_Parse (resp->body);
1448 if (parser == NULL || !cJSON_IsArray (parser))
1449 {
1450 err = 1;
1451 goto prefs_cleanup;
1452 }
1453
1454 cJSON_ArrayForEach (param_obj, parser)
1455 {
1456 gchar *defval = NULL, *param_type = NULL;
1457 openvasd_param_t *param = NULL;
1458 int val, mandatory = 0;
1459 char buf[6];
1460 cJSON *item = NULL;
1461
1462 item = cJSON_GetObjectItem (param_obj, "default");
1463 if (item != NULL)
1464 {
1465 if (cJSON_IsNumber (item))
1466 {
1467 val = item->valueint;
1468 g_snprintf (buf, sizeof (buf), "%d", val);
1469 defval = g_strdup (buf);
1470 param_type = g_strdup ("integer");
1471 }
1472 else if (cJSON_IsString (item))
1473 {
1474 defval = g_strdup (item->valuestring);
1475 param_type = g_strdup ("string");
1476 }
1477 else if (cJSON_IsBool (item))
1478 {
1479 if (cJSON_IsTrue (item))
1480 defval = g_strdup ("yes");
1481 else
1482 defval = g_strdup ("no");
1483 param_type = g_strdup ("boolean");
1484 }
1485 else
1486 {
1487 g_warning ("%s: Unable to parse scan preferences.", __func__);
1488 g_free (defval);
1489 g_free (param_type);
1490 continue;
1491 }
1492 }
1493
1494 param = openvasd_param_new (
1495 g_strdup (gvm_json_obj_str (param_obj, "id")),
1496 g_strdup (gvm_json_obj_str (param_obj, "name")), g_strdup (defval),
1497 g_strdup (gvm_json_obj_str (param_obj, "description")),
1498 g_strdup (param_type), mandatory);
1499 g_free (defval);
1500 g_free (param_type);
1501 *params = g_slist_append (*params, param);
1502 }
1503
1504prefs_cleanup:
1506 cJSON_Delete (parser);
1507 if (err)
1508 {
1509 g_warning ("%s: Unable to parse scan preferences.", __func__);
1510 return -1;
1511 }
1512
1513 return 0;
1514}
1515
1516// Scan config builder
1517static void
1518add_port_to_scan_json (gpointer range, gpointer p_array)
1519{
1520 range_t *ports = range;
1521
1522 cJSON *port = cJSON_CreateObject ();
1523 if (ports->type == 1)
1524 cJSON_AddStringToObject (port, "protocol", "udp");
1525 else
1526 cJSON_AddStringToObject (port, "protocol", "tcp");
1527
1528 cJSON *ranges_array = cJSON_CreateArray ();
1529 cJSON *range_obj = cJSON_CreateObject ();
1530 cJSON_AddNumberToObject (range_obj, "start", ports->start);
1531
1532 if (ports->end > ports->start && ports->end < 65535)
1533 cJSON_AddNumberToObject (range_obj, "end", ports->end);
1534 else
1535 cJSON_AddNumberToObject (range_obj, "end", ports->start);
1536 cJSON_AddItemToArray (ranges_array, range_obj);
1537 cJSON_AddItemToObject (port, "range", ranges_array);
1538 cJSON_AddItemToArray ((cJSON *) p_array, port);
1539}
1540
1541static void
1542add_credential_to_scan_json (gpointer credentials, gpointer cred_array)
1543{
1544 GHashTableIter auth_data_iter;
1545 gchar *auth_data_name, *auth_data_value;
1546 cJSON *cred_obj = NULL;
1547
1548 openvasd_credential_t *cred = credentials;
1549
1550 cred_obj = cJSON_CreateObject ();
1551 cJSON_AddStringToObject (cred_obj, "service", cred->service);
1552
1553 if (cred->port)
1554 {
1555 cJSON_AddNumberToObject (cred_obj, "port", atoi (cred->port));
1556 }
1557
1558 cJSON *cred_type_obj = cJSON_CreateObject ();
1559 g_hash_table_iter_init (&auth_data_iter, cred->auth_data);
1560 while (g_hash_table_iter_next (&auth_data_iter, (gpointer *) &auth_data_name,
1561 (gpointer *) &auth_data_value))
1562 cJSON_AddStringToObject (cred_type_obj, auth_data_name, auth_data_value);
1563 cJSON_AddItemToObject (cred_obj, cred->type, cred_type_obj);
1564
1565 cJSON_AddItemToArray ((cJSON *) cred_array, cred_obj);
1566}
1567
1568static void
1569add_scan_preferences_to_scan_json (gpointer key, gpointer val,
1570 gpointer scan_prefs_array)
1571{
1572 cJSON *pref_obj = cJSON_CreateObject ();
1573 cJSON_AddStringToObject (pref_obj, "id", key);
1574 cJSON_AddStringToObject (pref_obj, "value", val);
1575 cJSON_AddItemToArray (scan_prefs_array, pref_obj);
1576}
1577
1578static void
1579add_vts_to_scan_json (gpointer single_vt, gpointer vts_array)
1580{
1581 GHashTableIter vt_data_iter;
1582 gchar *vt_param_id, *vt_param_value;
1583
1584 openvasd_vt_single_t *vt = single_vt;
1585
1586 cJSON *vt_obj = cJSON_CreateObject ();
1587
1588 cJSON_AddStringToObject (vt_obj, "oid", vt->vt_id);
1589
1590 if (g_hash_table_size (vt->vt_values))
1591 {
1592 cJSON *params_array = cJSON_CreateArray ();
1593
1594 g_hash_table_iter_init (&vt_data_iter, vt->vt_values);
1595 while (g_hash_table_iter_next (&vt_data_iter, (gpointer *) &vt_param_id,
1596 (gpointer *) &vt_param_value))
1597 {
1598 cJSON *param_obj = cJSON_CreateObject ();
1599 cJSON_AddNumberToObject (param_obj, "id", atoi (vt_param_id));
1600 cJSON_AddStringToObject (param_obj, "value", vt_param_value);
1601 cJSON_AddItemToArray (params_array, param_obj);
1602 }
1603 cJSON_AddItemToObject (vt_obj, "parameters", params_array);
1604 }
1605 cJSON_AddItemToArray (vts_array, vt_obj);
1606}
1607
1620char *
1622 GHashTable *scan_preferences, GSList *vts)
1623{
1624 cJSON *scan_obj = NULL;
1625 cJSON *target_obj = NULL;
1626 cJSON *hosts_array = NULL;
1627 cJSON *exclude_hosts_array = NULL;
1628 cJSON *finished_hosts_array = NULL;
1629 gchar *json_str = NULL;
1630
1631 /* Build the message in json format to be published. */
1632 scan_obj = cJSON_CreateObject ();
1633
1634 if (target->scan_id && target->scan_id[0] != '\0')
1635 cJSON_AddStringToObject (scan_obj, "scan_id", target->scan_id);
1636
1637 // begin target
1638 target_obj = cJSON_CreateObject ();
1639
1640 // hosts
1641 hosts_array = cJSON_CreateArray ();
1642 gchar **hosts_list = g_strsplit (target->hosts, ",", 0);
1643 for (int i = 0; hosts_list[i] != NULL; i++)
1644 {
1645 cJSON *host_item = NULL;
1646 host_item = cJSON_CreateString (hosts_list[i]);
1647 cJSON_AddItemToArray (hosts_array, host_item);
1648 }
1649 g_strfreev (hosts_list);
1650 cJSON_AddItemToObject (target_obj, "hosts", hosts_array);
1651
1652 // exclude hosts
1653 if (target->exclude_hosts && target->exclude_hosts[0] != '\0')
1654 {
1655 exclude_hosts_array = cJSON_CreateArray ();
1656 gchar **exclude_hosts_list = g_strsplit (target->exclude_hosts, ",", 0);
1657 for (int i = 0; exclude_hosts_list[i] != NULL; i++)
1658 {
1659 cJSON *exclude_host_item = NULL;
1660 exclude_host_item = cJSON_CreateString (exclude_hosts_list[i]);
1661 cJSON_AddItemToArray (exclude_hosts_array, exclude_host_item);
1662 }
1663 g_strfreev (exclude_hosts_list);
1664 cJSON_AddItemToObject (target_obj, "excluded_hosts", exclude_hosts_array);
1665 }
1666
1667 // finished hosts
1668 if (target->finished_hosts && target->finished_hosts[0] != '\0')
1669 {
1670 finished_hosts_array = cJSON_CreateArray ();
1671 gchar **finished_hosts_list = g_strsplit (target->finished_hosts, ",", 0);
1672 for (int i = 0; finished_hosts_list[i] != NULL; i++)
1673 {
1674 cJSON *finished_host_item = NULL;
1675 finished_host_item = cJSON_CreateString (finished_hosts_list[i]);
1676 cJSON_AddItemToArray (finished_hosts_array, finished_host_item);
1677 }
1678 g_strfreev (hosts_list);
1679 cJSON_AddItemToObject (target_obj, "finished_hosts",
1680 finished_hosts_array);
1681 }
1682
1683 // ports
1684 if (target->ports && target->ports[0] != '\0')
1685 {
1686 cJSON *ports_array = cJSON_CreateArray ();
1687 array_t *ports = port_range_ranges (target->ports);
1688 g_ptr_array_foreach (ports, add_port_to_scan_json, ports_array);
1689 array_free (ports);
1690 cJSON_AddItemToObject (target_obj, "ports", ports_array);
1691 }
1692
1693 // credentials
1694 cJSON *credentials = cJSON_CreateArray ();
1695 g_slist_foreach (target->credentials, add_credential_to_scan_json,
1696 credentials);
1697 cJSON_AddItemToObject (target_obj, "credentials", credentials);
1698
1699 // reverse lookup
1700 if (target->reverse_lookup_unify)
1701 cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", cJSON_True);
1702 else
1703 cJSON_AddBoolToObject (target_obj, "reverse_lookup_unify", cJSON_False);
1704
1705 if (target->reverse_lookup_only)
1706 cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", cJSON_True);
1707 else
1708 cJSON_AddBoolToObject (target_obj, "reverse_lookup_only", cJSON_False);
1709
1710 // alive test methods
1711 cJSON *alive_test_methods = cJSON_CreateArray ();
1712 if (target->arp)
1713 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("arp"));
1714 if (target->tcp_ack)
1715 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_ack"));
1716 if (target->tcp_syn)
1717 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("tcp_syn"));
1718 if (target->consider_alive)
1719 cJSON_AddItemToArray (alive_test_methods,
1720 cJSON_CreateString ("consider_alive"));
1721 if (target->icmp)
1722 cJSON_AddItemToArray (alive_test_methods, cJSON_CreateString ("icmp"));
1723 cJSON_AddItemToObject (target_obj, "alive_test_methods", alive_test_methods);
1724
1725 cJSON_AddItemToObject (scan_obj, "target", target_obj);
1726
1727 // Begin Scan Preferences
1728 cJSON *scan_prefs_array = cJSON_CreateArray ();
1729 g_hash_table_foreach (scan_preferences, add_scan_preferences_to_scan_json,
1730 scan_prefs_array);
1731 cJSON_AddItemToObject (scan_obj, "scan_preferences", scan_prefs_array);
1732
1733 // Begin VTs
1734 cJSON *vts_array = cJSON_CreateArray ();
1735 g_slist_foreach (vts, add_vts_to_scan_json, vts_array);
1736 cJSON_AddItemToObject (scan_obj, "vts", vts_array);
1737
1738 json_str = cJSON_Print (scan_obj);
1739 cJSON_Delete (scan_obj);
1740 if (json_str == NULL)
1741 g_warning ("%s: Error while creating JSON.", __func__);
1742
1743 return json_str;
1744}
1745
1756openvasd_credential_new (const gchar *type, const gchar *service,
1757 const gchar *port)
1758{
1759 openvasd_credential_t *new_credential;
1760
1761 new_credential = g_malloc0 (sizeof (openvasd_credential_t));
1762
1763 new_credential->type = type ? g_strdup (type) : NULL;
1764 new_credential->service = service ? g_strdup (service) : NULL;
1765 new_credential->port = port ? g_strdup (port) : NULL;
1766 new_credential->auth_data =
1767 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1768
1769 return new_credential;
1770}
1771
1777void
1779{
1780 if (!credential)
1781 return;
1782
1783 g_free (credential->type);
1784 g_free (credential->service);
1785 g_free (credential->port);
1786 g_hash_table_destroy (credential->auth_data);
1787 g_free (credential);
1788}
1789
1797void
1799 const gchar *name, const gchar *value)
1800{
1801 if (credential == NULL || name == NULL)
1802 return;
1803
1804 if (g_regex_match_simple ("^[[:alpha:]][[:alnum:]_]*$", name, 0, 0))
1805 {
1806 if (value)
1807 g_hash_table_replace (credential->auth_data, g_strdup (name),
1808 g_strdup (value));
1809 else
1810 g_hash_table_remove (credential->auth_data, name);
1811 }
1812 else
1813 {
1814 g_warning ("%s: Invalid auth data name: %s", __func__, name);
1815 }
1816}
1817
1831openvasd_target_new (const gchar *scanid, const gchar *hosts,
1832 const gchar *ports, const gchar *exclude_hosts,
1833 int reverse_lookup_unify, int reverse_lookup_only)
1834{
1835 openvasd_target_t *new_target;
1836 new_target = g_malloc0 (sizeof (openvasd_target_t));
1837
1838 if (scanid && *scanid)
1839 new_target->scan_id = g_strdup (scanid);
1840
1841 new_target->exclude_hosts = exclude_hosts ? g_strdup (exclude_hosts) : NULL;
1842 new_target->finished_hosts = NULL;
1843 new_target->hosts = hosts ? g_strdup (hosts) : NULL;
1844 new_target->ports = ports ? g_strdup (ports) : NULL;
1845 new_target->reverse_lookup_unify =
1846 reverse_lookup_unify ? reverse_lookup_unify : 0;
1847 new_target->reverse_lookup_only =
1848 reverse_lookup_only ? reverse_lookup_only : 0;
1849
1850 return new_target;
1851}
1852
1859void
1861 const gchar *finished_hosts)
1862{
1863 g_free (target->finished_hosts);
1864 target->finished_hosts = finished_hosts ? g_strdup (finished_hosts) : NULL;
1865}
1866
1872void
1874{
1875 if (!target)
1876 return;
1877
1878 g_slist_free_full (target->credentials,
1879 (GDestroyNotify) openvasd_credential_free);
1880 g_free (target->exclude_hosts);
1881 g_free (target->finished_hosts);
1882 g_free (target->scan_id);
1883 g_free (target->hosts);
1884 g_free (target->ports);
1885 g_free (target);
1886 target = NULL;
1887}
1888
1899void
1901 gboolean icmp, gboolean tcp_syn,
1902 gboolean tcp_ack, gboolean arp,
1903 gboolean consider_alive)
1904{
1905 if (!target)
1906 return;
1907
1908 target->icmp = icmp;
1909 target->tcp_syn = tcp_syn;
1910 target->tcp_ack = tcp_ack;
1911 target->arp = arp;
1912 target->consider_alive = consider_alive;
1913}
1914
1921void
1923 openvasd_credential_t *credential)
1924{
1925 if (!target || !credential)
1926 return;
1927
1928 target->credentials = g_slist_prepend (target->credentials, credential);
1929}
1930
1939openvasd_vt_single_new (const gchar *vt_id)
1940{
1941 openvasd_vt_single_t *new_vt_single;
1942 new_vt_single = g_malloc0 (sizeof (openvasd_vt_single_t));
1943
1944 new_vt_single->vt_id = vt_id ? g_strdup (vt_id) : NULL;
1945 new_vt_single->vt_values =
1946 g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
1947
1948 return new_vt_single;
1949}
1950
1956void
1958{
1959 if (!vt_single)
1960 return;
1961
1962 g_hash_table_destroy (vt_single->vt_values);
1963
1964 g_free (vt_single->vt_id);
1965 g_free (vt_single);
1966}
1967
1977void
1979 const gchar *name, const gchar *value)
1980{
1981 g_hash_table_replace (vt_single->vt_values, g_strdup (name),
1982 g_strdup (value));
1983}
void array_free(GPtrArray *array)
Free global array value.
Definition array.c:50
GPtrArray array_t
Definition array.h:16
double gvm_json_obj_double(cJSON *obj, const gchar *key)
Get a double field from a JSON object.
Definition json.c:75
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
void openvasd_target_add_credential(openvasd_target_t *target, openvasd_credential_t *credential)
Add a credential to an openvasd target.
Definition openvasd.c:1922
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:263
void openvasd_param_free(openvasd_param_t *param)
Free an openvasd parameter.
Definition openvasd.c:1338
#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:1798
int openvasd_get_result_member_int(openvasd_result_t result, openvasd_result_member_int_t member)
Definition openvasd.c:747
void openvasd_target_free(openvasd_target_t *target)
Free an openvasd target, including all added credentials.
Definition openvasd.c:1873
openvasd_scan_status_t openvasd_parsed_scan_status(openvasd_connector_t conn)
Return a struct with the general scan status.
Definition openvasd.c:1087
char * openvasd_param_desc(openvasd_param_t *param)
Get the parameter description.
Definition openvasd.c:1383
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:685
void openvasd_reset_vt_stream(openvasd_connector_t conn)
Definition openvasd.c:433
void openvasd_credential_free(openvasd_credential_t *credential)
Free an openvasd credential.
Definition openvasd.c:1778
size_t openvasd_vt_stream_len(openvasd_connector_t conn)
Definition openvasd.c:445
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:1756
openvasd_resp_t openvasd_get_scan_results(openvasd_connector_t conn, long first, long last)
Definition openvasd.c:640
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:1621
char * openvasd_param_name(openvasd_param_t *param)
Get the parameter default.
Definition openvasd.c:1369
static void add_credential_to_scan_json(gpointer credentials, gpointer cred_array)
Definition openvasd.c:1542
openvasd_resp_t openvasd_get_scan_preferences(openvasd_connector_t conn)
Definition openvasd.c:1292
int openvasd_parsed_results(openvasd_connector_t conn, unsigned long first, unsigned long last, GSList **results)
Definition openvasd.c:863
int openvasd_param_mandatory(openvasd_param_t *param)
If the parameter is mandatory.
Definition openvasd.c:1425
openvasd_resp_t openvasd_get_vt_stream_init(openvasd_connector_t conn)
Initialized an curl multiperform handler which allows fetch feed metadata chunk by chunk.
Definition openvasd.c:365
int openvasd_parsed_performance(openvasd_connector_t conn, openvasd_get_performance_opts_t opts, gchar **graph, gchar **err)
Definition openvasd.c:1253
openvasd_resp_t openvasd_get_performance(openvasd_connector_t conn, openvasd_get_performance_opts_t opts)
Definition openvasd.c:1213
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:1831
void openvasd_result_free(openvasd_result_t result)
Definition openvasd.c:765
char * openvasd_get_result_member_str(openvasd_result_t result, openvasd_result_member_string_t member)
Definition openvasd.c:711
#define RESP_CODE_OK
Definition openvasd.c:32
int openvasd_get_scan_progress(openvasd_connector_t conn)
Definition openvasd.c:1023
static void add_port_to_scan_json(gpointer range, gpointer p_array)
Definition openvasd.c:1518
static openvasd_status_t get_status_code_from_openvas(const gchar *status_val)
Definition openvasd.c:1029
char * openvasd_param_type(openvasd_param_t *param)
Get the parameter type.
Definition openvasd.c:1397
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:1152
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:1860
static int get_member_value_or_fail(cJSON *reader, const gchar *member)
Get the value from an object or error.
Definition openvasd.c:924
void openvasd_vt_single_free(openvasd_vt_single_t *vt_single)
Free a single openvasd VT, including all preference values.
Definition openvasd.c:1957
openvasd_resp_t openvasd_get_version(openvasd_connector_t conn)
Request HEAD.
Definition openvasd.c:342
char * openvasd_param_default(openvasd_param_t *param)
Get the parameter default.
Definition openvasd.c:1411
static void add_scan_preferences_to_scan_json(gpointer key, gpointer val, gpointer scan_prefs_array)
Definition openvasd.c:1569
openvasd_resp_t openvasd_get_vts(openvasd_connector_t conn)
Get VT's metadata.
Definition openvasd.c:498
int openvasd_get_vt_stream(openvasd_connector_t conn)
Get a new feed metadata chunk.
Definition openvasd.c:462
openvasd_resp_t openvasd_start_scan(openvasd_connector_t conn, gchar *data)
Definition openvasd.c:524
static void add_vts_to_scan_json(gpointer single_vt, gpointer vts_array)
Definition openvasd.c:1579
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:1978
static int parse_status(const gchar *body, openvasd_scan_status_t status_info)
Definition openvasd.c:1050
openvasd_resp_t openvasd_get_health_started(openvasd_connector_t conn)
Definition openvasd.c:1193
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:1113
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:935
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:1900
gchar * openvasd_vt_stream_str(openvasd_connector_t conn)
Definition openvasd.c:439
openvasd_resp_t openvasd_stop_scan(openvasd_connector_t conn)
Definition openvasd.c:606
openvasd_resp_t openvasd_get_health_ready(openvasd_connector_t conn)
Definition openvasd.c:1172
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:1355
static int parse_results(const gchar *body, GSList **results)
Definition openvasd.c:786
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:1318
int openvasd_parsed_scans_preferences(openvasd_connector_t conn, GSList **params)
Definition openvasd.c:1434
openvasd_vt_single_t * openvasd_vt_single_new(const gchar *vt_id)
Create a new single openvasd VT.
Definition openvasd.c:1939
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:881
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
@ OPENVASD_INVALID_OPT
Definition openvasd.h:42
@ OPENVASD_INVALID_VALUE
Definition openvasd.h:44
@ OPENVASD_OK
Definition openvasd.h:46
@ 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
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
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
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
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
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