public async Task GetNvtFamiliesTest()
        {
            OpenvasApi             api     = new OpenvasApi(Address);
            GetNvtFamiliesResponse familes = await api.GetNvtFamilies();

            Assert.IsNotNull(familes.Families);
        }
        public async Task GetConfigsTest()
        {
            OpenvasApi        api    = new OpenvasApi(Address);
            GetConfigResponse config = await api.GetConfig();

            //string j = JsonConvert.SerializeObject(config);
        }
        public async Task GetCredentialsTest()
        {
            OpenvasApi            api        = new OpenvasApi(Address);
            GetCredentialResponse credential = await api.GetCredential();

            Assert.IsNotNull(credential?.Credentials);
        }
        public async Task GetVersionTest()
        {
            OpenvasApi api     = new OpenvasApi(Address);
            OmpVersion version = await api.GetOmpVersion();

            Assert.IsNotNull(version);
        }
        public async Task GetScannersTest()
        {
            OpenvasApi          api      = new OpenvasApi(Address);
            GetScannersResponse scanners = await api.GetScanners(new GetScannersRequest());

            Assert.IsNotNull(scanners.Scanners);
            string j = JsonConvert.SerializeObject(scanners);
        }
        public async Task GetResultsTest()
        {
            OpenvasApi         api     = new OpenvasApi(Address);
            GetResultsResponse results = await api.GetResults(new GetResultsRequest { TaskId = "f0a098e5-f8a4-43de-8176-bb823f7c0c06" });

            Assert.IsNotNull(results.Results);
            string j = JsonConvert.SerializeObject(results);
        }
        public async Task GetReportsTest()
        {
            OpenvasApi         api     = new OpenvasApi(Address);
            GetReportsResponse reports = await api.GetReports(new GetReportsRequest());// {ReportId = "4e1adb68-a2f7-409a-8393-926e9c8c7821" });

            Assert.IsNotNull(reports.Results);
            string j = JsonConvert.SerializeObject(reports);
        }
        public async Task GetTasksTest()
        {
            OpenvasApi       api   = new OpenvasApi(Address);
            GetTasksResponse tasks = await api.GetTasks(new GetTasksRequest());// { TaskId = "9f1c770b-22b6-4df9-9c2b-01b489ff466f" });

            Assert.IsNotNull(tasks.Tasks);

            string j = JsonConvert.SerializeObject(tasks);
        }
        public async Task GetTargetsTest()
        {
            OpenvasApi         api     = new OpenvasApi(Address);
            GetTargetsResponse targets = await api.GetTargets(new GetTargetsRequest());

            Assert.IsNotNull(targets.Targets);

            string j = JsonConvert.SerializeObject(targets);
        }
Beispiel #10
0
        protected override async Task <object> Run_Internal(IObserver observer, string asset, IScanRepository repository, object args)
        {
            if (String.IsNullOrEmpty(asset) || args == null)
            {
                return(null);
            }

            string     address = args?.ToString();
            OpenvasApi api     = new OpenvasApi(address);

            string taskId = asset;
            var    r      = await api.StartTask(taskId);

            if (r?.Status == "202")
            {
                while (true)
                {
                    await Task.Delay(1000);

                    GetTasksResponse tasks = await api.GetTasks(new GetTasksRequest { TaskId = taskId });

                    var first = tasks.Tasks.FirstOrDefault();
                    if (null != first)
                    {
                        if (first.Status == "Running" || first.Status == "Requested")
                        {
                            if (first.Progress is JObject jo)
                            {
                                observer.Notify("Openvas_" + taskId, "Progress: " + jo["_"], null);
                            }
                            else if (first.Progress is string progress)
                            {
                                observer.Notify("Openvas_" + taskId, "Progress: " + progress, null);
                            }

                            continue;
                        }
                        else
                        {
                            observer.Notify("Openvas_" + taskId, "Done at : " + DateTime.Now, null);
                        }
                    }
                    else
                    {
                        observer.Notify("Openvas_" + taskId, "couldn't get the task info, operation cancelled", null);
                    }

                    break;
                }
            }

            GetResultsResponse results = await api.GetResults(new GetResultsRequest { TaskId = taskId });

            return(results?.Results);
        }
        public async Task CreateCredentialTest()
        {
            OpenvasApi api          = new OpenvasApi(Address);
            var        resultCreate = await api.CreateCredential(new CreateCredentialRequest { Name = "user0", Login = "******", Password = "******", Comment = "this is my first time." });

            Assert.IsNotNull(resultCreate);

            var resultDelete = await api.DeleteCredential(new DeleteCredentialRequest { CredentialId = resultCreate?.Id });

            Assert.IsNotNull(resultDelete);
        }
        public async Task CreateTaskTest()
        {
            OpenvasApi api          = new OpenvasApi(Address);
            var        resultCreate = await api.CreateTask(new CreateTaskRequest
            {
                Name    = "Task For Testing",
                Comment = "Testing is our job.",
                Config  = "8715c877-47a0-438d-98a3-27c7a6ab2196", //discovery
                Target  = "bdeb8032-c1d2-489a-b8d2-3c229ed04b5c", //ankara
                Scanner = "08b69003-5fc2-4037-a479-93b440211c73"  //oepnvas default
            });

            Assert.IsNotNull(resultCreate);

            var r2 = await api.DeleteTask(new DeleteTaskRequest { TaskId = resultCreate?.Id });

            Assert.IsNotNull(r2);
        }
        public async Task CreateTargetTest()
        {
            OpenvasApi api          = new OpenvasApi(Address);
            var        resultCreate = await api.CreateTarget(new CreateTargetRequest
            {
                Name              = "AnkaraWnd via OMP",
                Comment           = "this is my first time.",
                Hosts             = "192.168.0.21",
                SshLscCredential  = "38c7abb1-aea4-4fde-8f46-3a582758e87c",
                SmbLscCredential  = "38c7abb1-aea4-4fde-8f46-3a582758e87c",
                EsxiLscCredential = "38c7abb1-aea4-4fde-8f46-3a582758e87c"
            });

            //string j11 = JsonConvert.SerializeObject(r11);
            Assert.IsNotNull(resultCreate);

            var r2 = await api.DeleteTarget(new DeleteTargetRequest { TargetId = resultCreate?.Id });

            Assert.IsNotNull(r2);
        }
        public async Task StartTaskTest()
        {
            const string taskId = "f0a098e5-f8a4-43de-8176-bb823f7c0c06"; //"d005a36d-8cf1-47f8-8b88-ef785d6b2aa2";
            OpenvasApi   api    = new OpenvasApi(Address);

            var r = await api.StartTask(taskId);

            Assert.IsNotNull(r);

            await Task.Delay(5000);

            var r2 = await api.StopTask(taskId);

            Assert.IsNotNull(r2);

            await Task.Delay(5000);

            var r3 = await api.ResumeTask(taskId);

            Assert.IsNotNull(r3);
        }