private static void GenerateXML(ReverseEngineeringData reverseEngineering, List<PermissionData> permissions, MalwareData malware, string codeReview, string appVerification)
        {
            XmlDocument xml = new XmlDocument();
            XmlNode docNode = xml.CreateXmlDeclaration("1.0", "UTF-8", null);
            xml.AppendChild(docNode);

            // <REPORT>
            XmlNode reportNode = xml.CreateElement("report");
            xml.AppendChild(reportNode);
            // </REPORT>

            // <FILE>
            XmlNode fileNode = xml.CreateElement("file");

            // FILE.MD5
            XmlAttribute md5 = xml.CreateAttribute("md5");
            md5.Value = reverseEngineering.MD5;
            fileNode.Attributes.Append(md5);

            // FILE.SHA1
            XmlAttribute sha1 = xml.CreateAttribute("sha1");
            sha1.Value = reverseEngineering.SHA1;
            fileNode.Attributes.Append(sha1);

            // FILE.SIZE
            XmlAttribute size = xml.CreateAttribute("size");
            size.Value = reverseEngineering.Size;
            fileNode.Attributes.Append(size);

            // FILE.NAME
            XmlAttribute fileName = xml.CreateAttribute("name");
            fileName.Value = reverseEngineering.FileName;
            fileNode.Attributes.Append(fileName);

            reportNode.AppendChild(fileNode);
            //</FILE>

            // <APP>
            XmlNode appNode = xml.CreateElement("app");

            // APP.NAME
            XmlAttribute appName = xml.CreateAttribute("name");
            appName.Value = reverseEngineering.AppName;
            appNode.Attributes.Append(appName);

            // APP.MINAPI
            XmlAttribute minApi = xml.CreateAttribute("minAPI");
            minApi.Value = "";
            appNode.Attributes.Append(minApi);

            // APP.VERSION
            XmlAttribute version = xml.CreateAttribute("version");
            version.Value = reverseEngineering.Version;
            appNode.Attributes.Append(version);

            // APP.PACKAGE
            XmlAttribute package = xml.CreateAttribute("package");
            package.Value = reverseEngineering.Package;
            appNode.Attributes.Append(package);

            reportNode.AppendChild(appNode);
            //</APP>

            // <PERMISSIONS>
            XmlNode permissionsNode = xml.CreateElement("permissions");
            appNode.AppendChild(permissionsNode);
            // </PERMISSIONS>

            if (permissions == null)
            {
                permissionsNode.AppendChild(xml.CreateTextNode("ERROR"));
            }
            else
            {
                foreach (var permission in permissions)
                {
                    //<PERMISSION>
                    XmlNode permissionNode = xml.CreateElement("permission");

                    // PERMISSION.NAME
                    XmlAttribute permissionName = xml.CreateAttribute("name");
                    permissionName.Value = permission.Name;
                    permissionNode.Attributes.Append(permissionName);

                    // PERMISSION.REQUIRED
                    XmlAttribute required = xml.CreateAttribute("required");
                    required.Value = permission.Required.ToString().ToLower();
                    permissionNode.Attributes.Append(required);

                    // PERMISSION.REQUIRED
                    XmlAttribute used = xml.CreateAttribute("used");
                    used.Value = permission.Used.ToString().ToLower();
                    permissionNode.Attributes.Append(used);

                    permissionsNode.AppendChild(permissionNode);
                    // </PERMISSION>
                }
            }
            // <ANALYSIS>
            XmlNode analysisNode = xml.CreateElement("analysis");
            reportNode.AppendChild(analysisNode);
            // </ANALYSIS>

            // <VIRUSTOTALSCORE>
            string virusTotal = (malware.Positive == "") ? "NOT AVAILABLE" : malware.Positive + "/" + malware.Total;
            XmlNode virusTotalScoreNode = xml.CreateElement("virusTotalScore");
            virusTotalScoreNode.AppendChild(xml.CreateTextNode(virusTotal));
            analysisNode.AppendChild(virusTotalScoreNode);
            // </VIRUSTOTALSCORE>

            // <OBFUSCATION>
            XmlNode obfuscationNode = xml.CreateElement("obfuscation");
            obfuscationNode.AppendChild(xml.CreateTextNode(reverseEngineering.Obfuscation + "%"));
            analysisNode.AppendChild(obfuscationNode);
            // </OBFUSCATION>

            // <APPVERIFICATION>
            string appVerificationNodeText = (appVerification == "") ? "NOT AVAILABLE" : "PASS";
            XmlNode appVerificationNode = xml.CreateElement("appVerification");
            appVerificationNode.AppendChild(xml.CreateTextNode(appVerificationNodeText));
            analysisNode.AppendChild(appVerificationNode);
            // </APPVERIFICATION>

            // <CODEREVIEW>
            string codeReviewNodeText = (codeReview == "") ? "NOT AVAILABLE" : "PASS";
            XmlNode codeReviewNode = xml.CreateElement("codeReview");
            codeReviewNode.AppendChild(xml.CreateTextNode(codeReviewNodeText));
            analysisNode.AppendChild(codeReviewNode);
            // </CODEREVIEW>

            // <NOTE>
            string noteMessage = "";
            int malwarePositive;

            if (permissions == null)
            {
                if (malware.IsEmpty())
                {
                    noteMessage = "Non è stato possibile analizzare la applicazione per scoprire eventuali malignità: sia la lista dei permessi che l'analisi degli antivirus online non è disponibile.";
                }
                else
                {
                    malwarePositive = Int32.Parse(malware.Positive);
                    if (malwarePositive <= 0)
                    {
                        noteMessage = "La lista dei permessi non è stata recuperata, nonostante questo l'analisi su " + malware.Total + " antivirus online non ha rilevato la presenza di sospette malignità.";
                    }
                    else if (malwarePositive == 1)
                    {
                        noteMessage = "L'analisi con gli antivirus online ha ottenuto un risultato positivo su " + malware.Total + ", dato che la lista dei permessi non è stata possibile da recuperare si consiglia una analisi manuale.";
                    }
                    else if (malwarePositive == 2)
                    {
                        noteMessage = "L'analisi con gli antivirus online ha ottenuto due risultati positivi su " + malware.Total + ", dato che la lista dei permessi non è stata possibile da recuperare si consiglia una analisi manuale.";
                    }
                    else
                    {
                        noteMessage = "Ben " + malwarePositive + " antivirus online hanno segnalato questa applicazione come maligna, unito al fatto che non è stato possibile recuperare la lista dei permessi, risulta sospetta.";
                    }
                }
            }
            else
            {
                if (malware.IsEmpty())
                {
                    if (ThereAreUsedNoRequestedPermissions(permissions))
                    {
                        noteMessage = "Non è stato possibile ottenere un risultato dagli antivirus online e risulta sospetto che ci siano dei permessi utilizzati che non vengono richiesti.";
                    }
                    else
                    {
                        noteMessage = "La scansione dell'applicazione con gli antivirus online non è stata possibile tuttavia la lista dei permessi non contiene nessun permesso utilizzato ma non richiesto: non sono presenti evidenti sospetti.";
                    }
                }
                else
                {
                    malwarePositive = Int32.Parse(malware.Positive);
                    if (ThereAreUsedNoRequestedPermissions(permissions))
                    {
                        if (malwarePositive <= 0)
                        {
                            noteMessage = "Nessun antivirus online segnala l'applicazione come malevola, però sono presenti permessi che vengono utilizzati senza richiesta.";
                        }
                        else if (malwarePositive == 1)
                        {
                            noteMessage = "Il fatto che ci siano dei permessi utilizzati senza richiesta e che un antivirus online abbia segnalato il file APK come malevolo, risulta sospetto. Consigliata analisi manuale.";
                        }
                        else if (malwarePositive == 2)
                        {
                            noteMessage = "Il fatto che ci siano dei permessi utilizzati senza richiesta e che due antivirus online abbiano segnalato il file APK come malevolo, risulta sospetto. Consigliata analisi manuale.";
                        }
                        else
                        {
                            noteMessage = "Risulta molto sospetto che " + malwarePositive + "antivirus online abbiano segnalato l'applicazione come malevola e che inoltre ci siano dei permessi che vengono utilizzati senza richiesta.";
                        }
                    }
                    else
                    {
                        if (malwarePositive <= 0)
                        {
                            noteMessage = "L'applicazione sembra essere innocua.";
                        }
                        else if (malwarePositive == 1)
                        {
                            noteMessage = "L'applicazione sembra essere innocua nonostante il fatto che un antivirus online la segnali come malevola, per una maggiore sicurezza si consiglia una scansione manuale.";
                        }
                        else if (malwarePositive == 2)
                        {
                            noteMessage = "L'applicazione sembra essere innocua nonostante il fatto che due antivirus online la segnalino come malevola, per una maggiore sicurezza si consiglia una scansione manuale.";
                        }
                        else
                        {
                            noteMessage = "I permessi risultano in regola, ma ben " + malwarePositive + " segnalano l'applicazione come dannosa. Analisi manuale fortemente consigliata.";
                        }
                    }
                }
            }

            XmlNode noteNode = xml.CreateElement("note");
            noteNode.AppendChild(xml.CreateTextNode(noteMessage));
            analysisNode.AppendChild(noteNode);
            // </NOTE>

            xml.Save("reports/" + reverseEngineering.Package.ToLower() + ".xml");
        }
        static ReverseEngineeringData GetReverseEngineeringReportData(string report)
        {
            Console.WriteLine("\tGetting Reverse Engineering data...");
            ReverseEngineeringData data = new ReverseEngineeringData()
            {
                AppName = "",
                FileName = "",
                MD5 = "",
                Obfuscation = "",
                Package = "",
                SHA1 = "",
                Size = "",
                Version = ""
            };

            if (report == "")
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("\tNo Reverse Engineering Report available.");
                Console.ResetColor();
                return data;
            }

            HtmlAgilityPack.HtmlDocument doc = new HtmlAgilityPack.HtmlDocument();
            doc.LoadHtml(report);

            var documentNode = doc.DocumentNode;

            data.AppName = documentNode.SelectSingleNode("//table[@id='res-table']/tr[1]/td[2]").InnerText.Trim();
            data.Package = documentNode.SelectSingleNode("//table[@id='res-table']/tr[1]/td[2]").InnerText.Trim();
            data.Version = documentNode.SelectSingleNode("//table[@id='res-table']/tr[2]/td[2]").InnerText.Trim();
            data.FileName = documentNode.SelectSingleNode("//table[@id='res-table']/tr[3]/td[2]").InnerText.Trim();
            data.Size = documentNode.SelectSingleNode("//table[@id='res-table']/tr[4]/td[2]").InnerText.Trim();
            data.Obfuscation = documentNode.SelectSingleNode("//table[@id='res-table']/tr[7]/td[2]").InnerText.Split('%')[0].Trim();
            data.MD5 = documentNode.SelectSingleNode("//table[@id='res-table']/tr[9]/td[2]").InnerText.Trim();
            data.SHA1 = documentNode.SelectSingleNode("//table[@id='res-table']/tr[10]/td[2]").InnerText.Trim();

            return data;
        }
        public void Update(ReverseEngineeringData reverseEngineeringData, List<PermissionData> permissionData, MalwareData malwareData, string appVerification, string codeReview)
        {
            if (!reverseEngineeringData.IsEmpty())
            {
                Obfuscation.Add(Convert.ToInt32(reverseEngineeringData.Obfuscation.Split('.')[0]));
                string name = reverseEngineeringData.Package.Split('.')[1].ToLower();
                if (AppDomain.ContainsKey(name))
                {
                    AppDomain[name]++;
                }
                else
                {
                    AppDomain.Add(name, 1);
                }
            }
            if (!malwareData.IsEmpty())
            {
                MalwareAnalysisAvailable++;
                if (Convert.ToInt32(malwareData.Positive) > 0)
                {
                    MalwarePositive++;
                }
            }
            if (appVerification != "")
            {
                AppVerification++;
            }
            if (codeReview != "")
            {
                CodeReviewPassed++;
            }

            int usedNotRequiredCheck = 0;
            int usedNotRequiredCount = 0;
            int combinationCheck = 0;
            if (permissionData != null)
            {
                PermissionAvailable++;
                int used = permissionData.Where(x => x.Used == true).Count();
                int required = permissionData.Where(x => x.Required == true).Count();
                if (used > required)
                {
                    AppPermissions[0]++;
                }
                else if (used == required)
                {
                    AppPermissions[1]++;
                }
                else
                {
                    AppPermissions[2]++;
                }
                foreach (PermissionData permission in permissionData)
                {
                    if (UsedPermissions.ContainsKey(permission.Name))
                    {
                        UsedPermissions[permission.Name]++;
                    }
                    else
                    {
                        UsedPermissions.Add(permission.Name, 1);
                    }
                    if (permission.IsUsedNotRequired())
                    {
                        usedNotRequiredCheck = 1;
                        if (UsedNotRequestedPermissions.ContainsKey(permission.Name))
                        {
                            UsedNotRequestedPermissions[permission.Name]++;
                        }
                        else
                        {
                            UsedNotRequestedPermissions.Add(permission.Name, 1);
                        }
                        if (combinationCheck == 0)
                        {
                            if (permission.Name == "INTERNET")
                            {
                                PermissionCombination++;
                                combinationCheck = 1;
                            }
                            else
                            {
                                if (permission.IsDanger())
                                {
                                    usedNotRequiredCount++;
                                    if (usedNotRequiredCount > 1)
                                    {
                                        PermissionCombination++;
                                        combinationCheck = 1;
                                    };
                                }
                            }
                        }
                    }
                    if (permission.IsRequiredNotUsed())
                    {
                        if (RequestedNotUsedPermissions.ContainsKey(permission.Name))
                        {
                            RequestedNotUsedPermissions[permission.Name]++;
                        }
                        else
                        {
                            RequestedNotUsedPermissions.Add(permission.Name, 1);
                        }
                    }
                    if (permission.IsUsedAndRequested())
                    {
                        if (UsedAndRequested.ContainsKey(permission.Name))
                        {
                            UsedAndRequested[permission.Name]++;
                        }
                        else
                        {
                            UsedAndRequested.Add(permission.Name, 1);
                        }
                    }
                }
            }
            AppUR += usedNotRequiredCheck;
        }