예제 #1
0
        public static bool IsThreat(AV_Report report)
        {
            foreach (var item in report.av_results)
            {
                if (!item.result.Equals("Clean"))
                {
                    return(true);
                }
            }

            return(false);
        }
예제 #2
0
        private void ShowReport()
        {
            AV_Reports reports = (AV_Reports)Settings.Get_Settings(typeof(AV_Reports));
            AV_Report  report  = reports.av_reports[reportid];

            label4.Text = report.file;
            label5.Text = report.time;

            Point offset = label3.Location;

            int distance  = 60;
            int step      = 15;
            int labelsize = 30;
            int x_step    = 200;

            font = label3.Font;

            foreach (AV_Result result in report.av_results)
            {
                distance += labelsize;
                distance += step;
                Label avname = new Label();
                avname.Location  = new Point(offset.X, offset.Y + distance);
                avname.Text      = result.av_name + ": ";
                avname.Font      = font;
                avname.ForeColor = date_color;
                avname.AutoSize  = true;

                Label av_value = new Label();
                av_value.Location = new Point(offset.X + x_step, offset.Y + distance);
                av_value.Text     = result.result;
                av_value.AutoSize = true;
                av_value.Font     = font;
                if (result.result.Equals("Clean"))
                {
                    av_value.ForeColor = clean_color;
                }
                else
                {
                    av_value.ForeColor = detected_color;
                }

                this.Controls.Add(avname);
                this.Controls.Add(av_value);
            }
        }
예제 #3
0
        private async Task <bool> ScanFiles(string taskid, bool runsafe)
        {
            Keys keys = Settings.GetKeys();

            bool PremiumAvailable = keys.key[1].value != null && !String.IsNullOrEmpty(keys.key[1].value);
            bool PublicAvailable  = keys.key[0].value != null && !String.IsNullOrEmpty(keys.key[0].value);
            bool PremiumActive    = keys.key[1].active;
            bool PublicActive     = keys.key[0].active;


            string key;
            int    scannedfiles = 0;
            int    totalfiles   = upload_files.Count;
            int    threatsfound = 0;
            bool   ispremium    = PremiumAvailable && PremiumActive;

            if (ispremium)
            {
                key = keys.key[1].value;
            }
            else
            {
                if (PublicAvailable && PublicActive)
                {
                    key = keys.key[0].value;
                }
                else
                {
                    return(false);
                }
            }

            List <string> active_avs = Settings.GetActiveAVs();
            AV_Reports    av_reports;

            try
            {
                av_reports = (AV_Reports)Settings.Get_Settings(typeof(AV_Reports));
            }
            catch
            {
                av_reports            = new AV_Reports();
                av_reports.av_reports = new List <AV_Report>();
            }

            List <string> queued_files = new List <string>();

            if (totalfiles == 1)
            {
                UpdateCurrentFile(upload_files[0]);
            }


            pictureBox4.Image   = Properties.Resources.loading;
            pictureBox4.Enabled = true;


            timer1.Enabled = true;
            timer1.Stop();
            timer1.Interval = 1000;
            start_time      = DateTime.Now;
            timer1.Start();
            timer1_Tick(null, null);


            foreach (var file in upload_files)
            {
                await Task.Delay(1000);


                AV_Report report = await VT_API.ScanFile(file, key, active_avs, false, ispremium, this);

                if (TaskCanceled(taskid))
                {
                    return(false);
                }


                if (report == null)
                {
                    queued_files.Add(file);
                }
                else
                {
                    UpdateCurrentFile(file);
                    av_reports.av_reports.Insert(0, report);
                    scannedfiles++;
                    if (VT_API.IsThreat(report))
                    {
                        threatsfound++;
                    }
                    UpdateLabels(scannedfiles, totalfiles, threatsfound);
                }
            }

            foreach (var file in queued_files)
            {
                UpdateCurrentFile(file);

                AV_Report report = await VT_API.ScanFile(file, key, active_avs, true, ispremium, this);

                if (TaskCanceled(taskid))
                {
                    return(false);
                }



                av_reports.av_reports.Insert(0, report);
                scannedfiles++;
                if (VT_API.IsThreat(report))
                {
                    threatsfound++;
                }
                UpdateLabels(scannedfiles, totalfiles, threatsfound);
            }



            Settings.Save_Settings(av_reports);
            tasks.Remove(taskid);
            timer1.Stop();
            timer1.Enabled = false;
            TogglePanel(panel1, false);
            TogglePanel(panel2, false);

            progressBar1.Tag = -1;

            FilesNum fileinfo = new FilesNum(totalfiles);

            fileinfo.threats  = threatsfound;
            fileinfo.duration = "0";
            fileinfo.duration = label15.Text;

            parent.last_history = 1;
            parent.btn_History_Click(fileinfo, null);

            if (openedmsg != null)
            {
                openedmsg.Close();
                openedmsg = null;
            }

            if (runsafe)
            {
                if (threatsfound > 0)
                {
                    notify_form.SetLabelMsg("Threats Found, no file(s) opened.", Color.FromArgb(192, 0, 0));
                    notify_form.ToggleButton(true);
                }
                else
                {
                    await Task.Run(() => StartFiles());

                    notify_form.SetLabelMsg("No Threats Found. Opening File(s)", Color.Green);
                    notify_form.DelayedClose(3000);
                }
            }

            return(true);
        }
예제 #4
0
        public static async Task <AV_Report> ScanFile(string filepath, string key, List <string> active_avs, bool queued, bool ispremium, Scan scanform)
        {
            AV_Report avreport = new AV_Report();

            VirusTotal       virusTotal = new VirusTotal(key);
            List <AV_Result> results    = new List <AV_Result>();

            virusTotal.UseTLS = true;
            byte[] filebytes = File.ReadAllBytes(filepath);
            string filehash;
            bool   report_fail;

            using (SHA256 sha256obj = SHA256.Create())
            {
                filehash = BytesToHexString(sha256obj.ComputeHash(filebytes));
            }
            FileReport obj_report  = null;
            dynamic    json_report = null;



            while (true)
            {
                try
                {
                    if (ispremium)
                    {
                        obj_report = await virusTotal.GetFileReportAsync(filebytes);

                        report_fail = obj_report.ResponseCode != FileReportResponseCode.Present;
                    }
                    else
                    {
                        string response_str = await GetReportData(filehash);


                        if (response_str != null)
                        {
                            json_report = JsonConvert.DeserializeObject(response_str);
                        }

                        report_fail = response_str == null || json_report.error != null;
                    }



                    if (report_fail)
                    {
                        if (queued)
                        {
                            await Task.Delay(bigtimeout);

                            continue;
                        }
                        else
                        {
                            await virusTotal.ScanFileAsync(filepath);

                            return(null);
                        }
                    }


                    avreport.file = filepath;
                    avreport.hash = filehash;
                    var      culture   = new CultureInfo("ro-RO");
                    DateTime localDate = DateTime.Now;

                    avreport.time = localDate.ToString(culture);


                    if (ispremium)
                    {
                        foreach (var item in active_avs)
                        {
                            ScanEngine scan = obj_report.Scans[item];


                            AV_Result result = new AV_Result();

                            result.av_name = item;


                            if (scan.Detected)
                            {
                                result.result = scan.Result;
                            }
                            else
                            {
                                result.result = "Clean";
                            }

                            results.Add(result);
                        }
                    }
                    else
                    {
                        dynamic scanresults = json_report.data.attributes.last_analysis_results;

                        foreach (var item in active_avs)
                        {
                            dynamic avresult = scanresults[item];

                            AV_Result result = new AV_Result();

                            result.av_name = item;


                            if (avresult.category == "malicious" && avresult.result != null)
                            {
                                result.result = avresult.result;
                            }
                            else
                            {
                                result.result = "Clean";
                            }

                            results.Add(result);
                        }
                    }
                    avreport.av_results = results;
                    return(avreport);
                }
                catch (Exception)
                {
                    bool res = await Settings.IsInternetAvailable();

                    if (!res)
                    {
                        if (scanform.net_msg != null)
                        {
                            scanform.net_msg.Close();
                        }
                        scanform.net_msg = new TotalMessage("Scan Error", "No internet connection :( ", MessageBoxButtons.OK);
                        scanform.net_msg.ShowDialog();
                        scanform.net_msg = null;
                    }

                    await Task.Delay(bigtimeout);

                    continue;
                }
            }
        }