Пример #1
0
        public static void Check(VulnerabilityCollection vulnerabilities, SystemInfo sysInfo)
        {
            try
            {
                int version = SystemInfoHelpers.GetFileVersionInfoProductPrivatePart(sysInfo.WinPath + "\\atmfd.dll");

                switch (sysInfo.OsBuild)
                {
                case "9200":
                    if (version < 243)
                    {
                        vulnerabilities.SetAsVulnerable("MS15-078");
                    }
                    break;

                case "9600":
                    if (version < 243)
                    {
                        vulnerabilities.SetAsVulnerable("MS15-078");
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                vulnerabilities.AddError(ex.Message);
            }
        }
Пример #2
0
        public static void Check(VulnerabilityCollection vulnerabilities, SystemInfo sysInfo)
        {
            try
            {
                int version = SystemInfoHelpers.GetFileVersionInfoProductPrivatePart(sysInfo.WinPath + "\\schedsvc.dll");

                switch (sysInfo.OsBuild)
                {
                case "6001":
                    if (version < 18551)
                    {
                        vulnerabilities.SetAsVulnerable("MS10-092");
                    }
                    break;

                case "6002":
                    if (version < 18342)
                    {
                        vulnerabilities.SetAsVulnerable("MS10-092");
                    }
                    break;

                case "7600":
                    if (version < 16699)
                    {
                        vulnerabilities.SetAsVulnerable("MS10-092");
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                vulnerabilities.AddError(ex.Message);
            }
        }
Пример #3
0
        public static void Check(VulnerabilityCollection vulnerabilities, SystemInfo sysInfo)
        {
            try
            {
                int version = SystemInfoHelpers.GetFileVersionInfoProductPrivatePart(sysInfo.WinPath + "\\gpprefcl.dll");

                switch (sysInfo.OsBuild)
                {
                case "10240":
                    if (version < 16942)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-072");
                    }
                    break;

                case "10586":
                    if (version < 420)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-072");
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                vulnerabilities.AddError(ex.Message);
            }
        }
Пример #4
0
        public static void Check(VulnerabilityCollection vulnerabilities, string BuildNumber, List <string> installedKBs)
        {
            List <string> Supersedence = new List <string>();

            switch (BuildNumber)
            {
            case "18362":
            case "18363":

                Supersedence.AddRange(new string[] {
                    "4551762"
                });

                break;

            default:
                return;
            }

            IEnumerable <string> x = Supersedence.Intersect(installedKBs);

            if (!x.Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #5
0
        public static void Check(VulnerabilityCollection vulnerabilities, string BuildNumber, List <string> installedKBs)
        {
            List <string> Supersedence = new List <string>();

            switch (BuildNumber)
            {
            case "15063":

                Supersedence.AddRange(new string[] {
                    "4503279", "4503289", "4509476", "4507450"
                });

                break;

            case "16299":

                Supersedence.AddRange(new string[] {
                    "4503284", "4503281", "4509477", "4507455"
                });

                break;

            case "17134":

                Supersedence.AddRange(new string[] {
                    "4503286", "4503288", "4509478", "4507435"
                });

                break;

            case "17763":

                Supersedence.AddRange(new string[] {
                    "4503327", "4501371", "4509479", "4507469"
                });

                break;

            case "18362":

                Supersedence.AddRange(new string[] {
                    "4503293", "4501375", "4507453"
                });

                break;

            default:
                return;
            }

            IEnumerable <string> x = Supersedence.Intersect(installedKBs);

            if (!x.Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #6
0
        public static void Check(VulnerabilityCollection vulnerabilities, string BuildNumber, List <string> installedKBs)
        {
            List <string> Supersedence = new List <string>();

            switch (BuildNumber)
            {
            case "15063":

                Supersedence.AddRange(new string[] {
                    "4507450", "4507467", "4512507"
                });

                break;

            case "16299":

                Supersedence.AddRange(new string[] {
                    "4507455", "4507465", "4512516"
                });

                break;

            case "17134":

                Supersedence.AddRange(new string[] {
                    "4507435", "4507466", "4512501"
                });

                break;

            case "17763":

                Supersedence.AddRange(new string[] {
                    "4507469", "4505658", "4511553"
                });

                break;

            case "18362":

                Supersedence.AddRange(new string[] {
                    "4507453", "4505903", "4512508"
                });

                break;

            default:
                return;
            }

            IEnumerable <string> x = Supersedence.Intersect(installedKBs);

            if (!x.Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #7
0
        public static void Check(VulnerabilityCollection vulnerabilities, string BuildNumber, List <string> installedKBs)
        {
            List <string> Supersedence = new List <string>();

            switch (BuildNumber)
            {
            case "15063":

                Supersedence.AddRange(new string[] {
                    "4499181", "4499162", "4505055", "4503279"
                });

                break;

            case "16299":

                Supersedence.AddRange(new string[] {
                    "4499179", "4499147", "4505062", "4503284"
                });

                break;

            case "17134":

                Supersedence.AddRange(new string[] {
                    "4499167", "4499183", "4505064", "4503286"
                });

                break;

            case "17763":

                Supersedence.AddRange(new string[] {
                    "4494441", "4497934", "4505056", "4503327"
                });

                break;

            case "18362":

                Supersedence.AddRange(new string[] {
                    "4497936", "4497935", "4505057", "4503293"
                });

                break;

            default:
                return;
            }

            IEnumerable <string> x = Supersedence.Intersect(installedKBs);

            if (!x.Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #8
0
        public static void Check(VulnerabilityCollection vulnerabilities, SystemInfo sysInfo)
        {
            try
            {
                int version = SystemInfoHelpers.GetFileVersionInfoProductPrivatePart(sysInfo.WinPath + "\\drivers\\mrxdav.sys");

                switch (sysInfo.OsBuild)
                {
                case "6002":
                    if (version < 19576)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-016");
                    }
                    break;

                case "9600":
                    if (version < 18189)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-016");
                    }
                    break;

                case "10240":
                    if (version < 16683)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-016");
                    }
                    break;

                case "10586":
                    if (version < 103)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-016");
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                vulnerabilities.AddError(ex.Message);
            }
        }
Пример #9
0
        public static void Check(VulnerabilityCollection vulnerabilities, SystemInfo sysInfo)
        {
            try
            {
                int version = SystemInfoHelpers.GetFileVersionInfoProductPrivatePart(sysInfo.WinPath + "\\seclogon.dll");

                switch (sysInfo.OsBuild)
                {
                case "6002":
                    if (version < 19598 && sysInfo.CpuCount > 1)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-032");
                    }
                    break;

                case "9600":
                    if (version < 18230 && sysInfo.CpuCount > 1)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-032");
                    }
                    break;

                case "10240":
                    if (version < 16724 && sysInfo.CpuCount > 1)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-032");
                    }
                    break;

                case "10586":
                    if (version < 162 && sysInfo.CpuCount > 1)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-032");
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                vulnerabilities.AddError(ex.Message);
            }
        }
Пример #10
0
        public static void Check(VulnerabilityCollection vulnerabilities, string BuildNumber, List <string> installedKBs)
        {
            List <string> Supersedence = new List <string>();

            switch (BuildNumber)
            {
            case "15063":

                Supersedence.AddRange(new string[]
                {
                    "4103731"
                });

                break;

            case "16299":

                Supersedence.AddRange(new string[]
                {
                    "4103727", "4103714", "4284819", "4284822", "4338817", "4338825", "4345420",
                    "4343893", "4343897", "4457136", "4457142", "4464217", "4462918", "4462932",
                    "4467681", "4467686", "4471329", "4483232", "4480967", "4480978", "4486996",
                    "4487021", "4489886", "4489890", "4493440", "4493441", "4499147", "4499179",
                    "4505062"
                });

                break;

            case "17134":

                Supersedence.AddRange(new string[]
                {
                    "4103721", "4100403", "4284835", "4284848", "4338819", "4340917", "4345421",
                    "4343909", "4346783", "4457128", "4458469", "4464218", "4462919", "4462933",
                    "4467702", "4471324", "4483234", "4480966", "4480976", "4487017", "4487029",
                    "4489868", "4489894", "4493437", "4493464", "4499167", "4499183", "4505064"
                });

                break;

            default:
                return;
            }

            IEnumerable <string> x = Supersedence.Intersect(installedKBs);

            if (!x.Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #11
0
        public static void Check(VulnerabilityCollection vulnerabilities, SystemInfo sysInfo)
        {
            try
            {
                int version = SystemInfoHelpers.GetFileVersionInfoProductPrivatePart(sysInfo.WinPath + "\\drivers\\afd.sys");

                switch (sysInfo.OsBuild)
                {
                case "6001":
                    if (version < 18639)
                    {
                        vulnerabilities.SetAsVulnerable("MS11-046");
                    }

                    break;

                case "6002":
                    if (version < 18457)
                    {
                        vulnerabilities.SetAsVulnerable("MS11-046");
                    }

                    break;

                case "7600":
                    if (version < 16802)
                    {
                        vulnerabilities.SetAsVulnerable("MS11-046");
                    }

                    break;
                }
            }
            catch (Exception ex)
            {
                vulnerabilities.AddError(ex.Message);
            }
        }
Пример #12
0
        public static void Check(VulnerabilityCollection vulnerabilities, string BuildNumber, List <string> installedKBs)
        {
            List <string> Supersedence = new List <string>();

            switch (BuildNumber)
            {
            case "15063":

                Supersedence.AddRange(new string[] {
                    "4493474", "4493436", "4499162", "4499181", "4502112", "4505055", "4503279", "4503289", "4509476", "4507450", "4507467", "4512507"
                });

                break;

            case "16299":

                Supersedence.AddRange(new string[] {
                    "4493441", "4493440", "4499147", "4499179", "4505062", "4503281", "4503284", "4509477", "4507455", "4507465", "4512516"
                });

                break;

            case "17134":

                Supersedence.AddRange(new string[] {
                    "4493464", "4493437", "4499167", "4499183", "4505064", "4503286", "4503288", "4509478", "4507435", "4507466", "4512501"
                });

                break;

            case "17763":

                Supersedence.AddRange(new string[] {
                    "4493509", "4495667", "4494441", "4497934", "4501835", "4505056", "4501371", "4503327", "4509479", "4505658", "4507469", "4511553"
                });

                break;

            default:
                return;
            }

            IEnumerable <string> x = Supersedence.Intersect(installedKBs);

            if (!x.Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #13
0
        public static void Check(VulnerabilityCollection vulnerabilities, SystemInfo sysInfo)
        {
            try
            {
                int version = SystemInfoHelpers.GetFileVersionInfoProductPrivatePart(sysInfo.WinPath + "\\pcadm.dll");

                switch (sysInfo.OsBuild)
                {
                case "10240":
                    if (version < 17861)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-8897");
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                vulnerabilities.AddError(ex.Message);
            }
        }
Пример #14
0
        public static void Check(VulnerabilityCollection vulnerabilities, SystemInfo sysInfo)
        {
            try
            {
                int version = SystemInfoHelpers.GetFileVersionInfoProductPrivatePart(sysInfo.WinPath + "\\win32kfull.sys");

                switch (sysInfo.OsBuild)
                {
                case "10240":
                    if (version < 16683)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-014");
                    }
                    if (version < 16724)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-034");
                    }
                    if (version < 16771)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-039");
                    }
                    break;

                case "10586":
                    if (version < 103)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-014");
                    }
                    if (version < 162)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-034");
                    }
                    if (version < 212)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-039");
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                vulnerabilities.AddError(ex.Message);
            }
        }
Пример #15
0
        public static void Check(VulnerabilityCollection vulnerabilities, int buildNumber, List <int> installedKBs)
        {
            var supersedence = new List <int>();

            switch (buildNumber)
            {
            case 18362:
            case 18363:

                supersedence.AddRange(new int[] {
                    4551762
                });

                break;

            default:
                return;
            }

            if (!supersedence.Intersect(installedKBs).Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #16
0
        public static void Check(VulnerabilityCollection vulnerabilities, SystemInfo sysInfo)
        {
            try
            {
                int version = SystemInfoHelpers.GetFileVersionInfoProductPrivatePart(sysInfo.WinPath + "\\gdi32.dll");

                switch (sysInfo.OsBuild)
                {
                case "10240":
                    if (version < 17319)
                    {
                        vulnerabilities.SetAsVulnerable("MS17-012");
                        vulnerabilities.SetAsVulnerable("MS17-017");
                    }
                    if (version < 17394)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2017-0263");
                    }
                    break;

                case "10586":
                    if (version < 839)
                    {
                        vulnerabilities.SetAsVulnerable("MS17-012");
                        vulnerabilities.SetAsVulnerable("MS17-017");
                    }
                    if (version < 916)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2017-0263");
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                vulnerabilities.AddError(ex.Message);
            }
        }
Пример #17
0
        public static void Check(VulnerabilityCollection vulnerabilities, int buildNumber, List <int> installedKBs)
        {
            var supersedence = new List <int>();

            switch (buildNumber)
            {
            case 10240:

                supersedence.AddRange(new int[] {
                    4507458, 4512497, 4517276, 4522009, 4520011,
                    4524153, 4525232, 4530681, 4534306, 4537776,
                    4540693, 4550930, 4556826, 4561649, 4567518,
                    4565513, 4571692, 4577049
                });

                break;

            case 14393:

                supersedence.AddRange(new int[] {
                    4507460, 4507459, 4512495, 4512517, 4516044,
                    4516061, 4522010, 4519998, 4524152, 4525236,
                    4530689
                });

                break;

            case 15063:

                supersedence.AddRange(new int[] {
                    4507460, 4507459, 4512495, 4512517, 4516044,
                    4516061, 4522010, 4519998, 4524152, 4525236,
                    4530689
                });

                break;

            case 16299:

                supersedence.AddRange(new int[] {
                    4507455, 4507465, 4512494, 4512516, 4516066,
                    4522012, 4520004, 4520006, 4524150, 4525241,
                    4530714, 4534276, 4534318, 4537789, 4537816,
                    4540681, 4541330, 4554342, 4550927, 4556812,
                    4561602, 4567515, 4565508, 4571741, 4577041
                });

                break;

            case 17134:

                supersedence.AddRange(new int[] {
                    4507435, 4507466, 4512501, 4512509, 4516045,
                    4516058, 4522014, 4519978, 4520008, 4524149,
                    4525237, 4530717, 4534293, 4534308, 4537762,
                    4537795, 4540689, 4541333, 4554349, 4550922,
                    4550944, 4556807, 4561621, 4567514, 4565489,
                    4571709, 4577032
                });

                break;

            case 17763:

                supersedence.AddRange(new int[] {
                    4507469, 4505658, 4511553, 4512534, 4512578,
                    4522015, 4519338, 4520062, 4524148, 4523205,
                    4530715, 4534273, 4534321, 4532691, 4537818,
                    4538461, 4541331, 4554354, 4549949, 4550969,
                    4551853, 4561608, 4567513, 4558998, 4559003,
                    4565349, 4571748, 4570333, 4577069
                });

                break;

            case 18362:

                supersedence.AddRange(new int[] {
                    4507453, 4505903, 4512508, 4512941, 4515384,
                    4517211, 4522016, 4517389, 4522355, 4524147,
                    4524570, 4530684, 4528760, 4532695, 4532693,
                    4535996, 4540673, 4541335, 4551762, 4554364,
                    4549951, 4550945, 4556799, 4560960, 4567512,
                    4565483, 4559004, 4565351, 4566116, 4574727,
                    4577062
                });

                break;

            default:
                return;
            }

            if (supersedence.Intersect(installedKBs).Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #18
0
        public static void Check(VulnerabilityCollection vulnerabilities, SystemInfo sysInfo)
        {
            try
            {
                int version = SystemInfoHelpers.GetFileVersionInfoProductPrivatePart(sysInfo.WinPath + "\\ntoskrnl.exe");

                switch (sysInfo.OsBuild)
                {
                case "6000":
                    if (version < 16973)
                    {
                        vulnerabilities.SetAsVulnerable("MS10-015");
                    }
                    break;

                case "6001":
                    if (version < 18377)
                    {
                        vulnerabilities.SetAsVulnerable("MS10-015");
                    }
                    break;

                case "6002":
                    if (version < 18160)
                    {
                        vulnerabilities.SetAsVulnerable("MS10-015");
                    }
                    break;

                case "10240":
                    if (version < 17113)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-111");
                    }
                    if (version < 17184)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-135");
                        vulnerabilities.SetAsVulnerable("MS16-138");
                    }
                    if (version < 17946)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-0952");
                    }
                    if (version < 17976)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-8440");
                    }
                    break;

                case "10586":
                    if (version < 589)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-111");
                    }
                    if (version < 672)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-135");
                        vulnerabilities.SetAsVulnerable("MS16-138");
                    }
                    break;

                case "14393":
                    if (version < 953)
                    {
                        vulnerabilities.SetAsVulnerable("MS17-012");
                        vulnerabilities.SetAsVulnerable("MS17-017");
                    }
                    if (version < 1198)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2017-0263");
                    }
                    if (version < 2248)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-8897");
                    }
                    if (version < 2430)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-0952");
                    }
                    if (version < 2485)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-8440");
                    }
                    break;

                case "15063":
                    if (version < 296)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2017-0263");
                    }
                    if (version < 483)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-111");
                    }
                    if (version < 608)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-039");
                        vulnerabilities.SetAsVulnerable("MS16-123");
                    }
                    if (version < 1266)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-0952");
                    }
                    if (version < 1324)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-8440");
                    }
                    break;

                case "16299":
                    if (version < 611)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-0952");
                    }
                    if (version < 665)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-8440");
                    }
                    break;

                case "17134":
                    if (version < 48)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-8897");
                    }
                    if (version < 228)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-0952");
                    }
                    if (version < 285)
                    {
                        vulnerabilities.SetAsVulnerable("CVE-2018-8440");
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                vulnerabilities.AddError(ex.Message);
            }
        }
Пример #19
0
        public static void Check(VulnerabilityCollection vulnerabilities, string BuildNumber, List <string> installedKBs)
        {
            List <string> Supersedence = new List <string>();

            switch (BuildNumber)
            {
            case "10240":

                Supersedence.AddRange(new string[] {
                    "4493475", "4498375", "4499154", "4505051", "4503291",
                    "4507458", "4512497", "4517276", "4516070", "4522009",
                    "4520011", "4524153", "4525232", "4530681"
                });

                break;

            case "10586":

                Supersedence.AddRange(new string[] {
                    //
                });

                break;

            case "14393":

                Supersedence.AddRange(new string[] {
                    "4493470", "4493473", "4499418", "4494440", "4499177",
                    "4505052", "4503267", "4503294", "4509475", "4507459",
                    "4507460", "4512495", "4512517", "4516044", "4516061",
                    "4522010", "4519998", "4524152", "4525236", "4530689"
                });

                break;

            case "15063":

                Supersedence.AddRange(new string[] {
                    "4493474", "4493436", "4499162", "4499181", "4502112",
                    "4505055", "4503279", "4503289", "4509476", "4507450",
                    "4507467", "4512474", "4512507", "4516059", "4516068",
                    "4522011", "4520010", "4524151", "4525245", "4530711"
                });

                break;

            case "16299":

                Supersedence.AddRange(new string[] {
                    "4493441", "4493440", "4499147", "4499179", "4505062",
                    "4503281", "4503284", "4509477", "4507455", "4507465",
                    "4512494", "4512516", "4516066", "4516071", "4522012",
                    "4520004", "4524150", "452524", "4530714"
                });

                break;

            case "17134":

                Supersedence.AddRange(new string[] {
                    "4493464", "4493437", "4499167", "4499183", "4505064",
                    "4503286", "4503288", "4509478", "4507435", "4507466",
                    "4512501", "4512509", "4516045", "4516058", "4522014",
                    "4520008", "4524149", "4525237", "B4530717"
                });

                break;

            case "17763":

                Supersedence.AddRange(new string[] {
                    "4493509", "4495667", "4494441", "4497934", "4501835",
                    "4505056", "4501371", "4503327", "4509479", "4505658",
                    "4507469", "4511553", "4512534", "4512578", "4516077",
                    "4522015", "4519338", "4524148", "4523205", "4530715"
                });

                break;

            default:
                return;
            }

            IEnumerable <string> x = Supersedence.Intersect(installedKBs);

            if (!x.Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #20
0
        public static void Check(VulnerabilityCollection vulnerabilities, int buildNumber, List <int> installedKBs)
        {
            var supersedence = new List <int>();

            switch (buildNumber)
            {
            case 10240:

                supersedence.AddRange(new int[] {
                    4577049
                });

                break;

            case 14393:

                supersedence.AddRange(new int[] {
                    4577015
                });

                break;

            case 16299:

                supersedence.AddRange(new int[] {
                    4577041
                });

                break;

            case 17134:

                supersedence.AddRange(new int[] {
                    4577032
                });

                break;

            case 17763:

                supersedence.AddRange(new int[] {
                    4570333, 4577069
                });

                break;

            case 18362:

                supersedence.AddRange(new int[] {
                    4574727, 4577062
                });

                break;

            case 18363:

                supersedence.AddRange(new int[] {
                    4574727, 4577062
                });

                break;

            case 19041:

                supersedence.AddRange(new int[] {
                    4571756, 4577063
                });

                break;

            default:
                return;
            }

            if (supersedence.Intersect(installedKBs).Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #21
0
        public static void Check(VulnerabilityCollection vulnerabilities, string BuildNumber, List <string> installedKBs)
        {
            List <string> Supersedence = new List <string>();

            switch (BuildNumber)
            {
            case "10240":

                Supersedence.AddRange(new string[] {
                    //
                });

                break;

            case "10586":

                Supersedence.AddRange(new string[] {
                    //
                });

                break;

            case "14393":

                Supersedence.AddRange(new string[] {
                    "4503267", "4503294", "4509475", "4507459", "4507460",
                    "4512495", "4512517", "4516044", "4516061", "4522010",
                    "4519998", "4524152"
                });

                break;

            case "15063":

                Supersedence.AddRange(new string[] {
                    "4503279", "4503289", "4509476", "4507450", "4507467",
                    "4512474", "4512507", "4516059", "4516068", "4522011",
                    "4520010", "4524151"
                });

                break;

            case "16299":

                Supersedence.AddRange(new string[] {
                    "4503284", "4503281", "4509477", "4507455", "4507465",
                    "4512494", "4512516", "4516066", "4516071", "4522012",
                    "4520004", "4524150"
                });

                break;

            case "17134":

                Supersedence.AddRange(new string[] {
                    "4503286", "4503288", "4509478", "4507435", "4507466",
                    "4512501", "4512509", "4516045", "4516058", "4522014",
                    "4520008", "4524149"
                });

                break;

            case "17763":

                Supersedence.AddRange(new string[] {
                    "4503327", "4501371", "4509479", "4505658", "4507469",
                    "4511553", "4512534", "4512578", "4516077", "4522015",
                    "4519338", "4524148"
                });

                break;

            case "18362":

                Supersedence.AddRange(new string[] {
                    "4503293", "4501375", "4505903", "4507453", "4512508",
                    "4512941", "4515384", "4517211", "4522016", "4517389",
                    "4524147"
                });

                break;

            default:
                return;
            }

            IEnumerable <string> x = Supersedence.Intersect(installedKBs);

            if (!x.Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #22
0
        public static void Check(VulnerabilityCollection vulnerabilities, string BuildNumber, List <string> installedKBs)
        {
            List <string> Supersedence = new List <string>();

            switch (BuildNumber)
            {
            case "10240":

                Supersedence.AddRange(new string[] {
                    //
                });

                break;

            case "10586":

                Supersedence.AddRange(new string[] {
                    //
                });

                break;

            case "14393":

                Supersedence.AddRange(new string[] {
                    //
                });

                break;

            case "15063":

                Supersedence.AddRange(new string[] {
                    "4516068", "4516059", "4522011", "4520010", "4524151",
                    "4525245", "4530711"
                });

                break;

            case "16299":

                Supersedence.AddRange(new string[] {
                    "4516066", "4516071", "4522012", "4520004", "4524150",
                    "4525241", "4530714"
                });

                break;

            case "17134":

                Supersedence.AddRange(new string[] {
                    "4516058", "4516045", "4522014", "4520008", "4524149",
                    "4525237", "4530717"
                });

                break;

            case "17763":

                Supersedence.AddRange(new string[] {
                    "4512578", "4516077", "4522015", "4519338", "4524148",
                    "4523205", "4530715"
                });

                break;

            case "18362":

                Supersedence.AddRange(new string[] {
                    "4515384", "4517211", "4522016", "4517389", "4524147",
                    "4524570", "4530684"
                });

                break;

            default:
                return;
            }

            IEnumerable <string> x = Supersedence.Intersect(installedKBs);

            if (!x.Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #23
0
        public static void Check(VulnerabilityCollection vulnerabilities, string BuildNumber, List <string> installedKBs)
        {
            List <string> Supersedence = new List <string>();

            switch (BuildNumber)
            {
            case "10240":

                Supersedence.AddRange(new string[] {
                    "4525232", "4530681"
                });

                break;

            case "10586":

                Supersedence.AddRange(new string[] {
                    //
                });

                break;

            case "14393":

                Supersedence.AddRange(new string[] {
                    "4525236", "4530689"
                });

                break;

            case "15063":

                Supersedence.AddRange(new string[] {
                    //
                });

                break;

            case "16299":

                Supersedence.AddRange(new string[] {
                    "4525241", "4530714"
                });

                break;

            case "17134":

                Supersedence.AddRange(new string[] {
                    "4525237", "4530717"
                });

                break;

            case "17763":

                Supersedence.AddRange(new string[] {
                    "4523205", "4530715"
                });

                break;

            case "18362":

                Supersedence.AddRange(new string[] {
                    "4524570", "4530684"
                });

                break;

            default:
                return;
            }

            IEnumerable <string> x = Supersedence.Intersect(installedKBs);

            if (!x.Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #24
0
        public static void Check(VulnerabilityCollection vulnerabilities, int buildNumber, List <int> installedKBs)
        {
            var supersedence = new List <int>();

            switch (buildNumber)
            {
            case 16299:

                supersedence.AddRange(new int[] {
                    4525241, 4530714, 4534276, 4534318, 4537789,
                    4537816, 4540681, 4541330, 4554342, 4550927,
                    4556812, 4561602, 4567515, 4565508, 4571741,
                    4577041
                });

                break;

            case 17134:

                supersedence.AddRange(new int[] {
                    4525237, 4530717, 4534293, 4534308, 4537762,
                    4537795, 4540689, 4541333, 4554349, 4550922,
                    4550944, 4556807, 4561621, 4567514, 4565489,
                    4571709, 4577032
                });

                break;

            case 17763:

                supersedence.AddRange(new int[] {
                    4523205, 4530715, 4534273, 4534321, 4532691,
                    4537818, 4538461, 4541331, 4554354, 4549949,
                    4550969, 4551853, 4561608, 4567513, 4558998,
                    4559003, 4565349, 4571748, 4570333, 4577069
                });

                break;

            case 18362:

                supersedence.AddRange(new int[] {
                    4524570, 4530684, 4528760, 4532695, 4532693,
                    4535996, 4540673, 4541335, 4551762, 4554364,
                    4549951, 4550945, 4556799, 4560960, 4567512,
                    4565483, 4559004, 4565351, 4566116, 4574727,
                    4577062
                });

                break;

            case 18363:

                supersedence.AddRange(new int[] {
                    4524570, 4530684, 4528760, 4532695, 4532693,
                    4535996, 4540673, 4541335, 4551762, 4554364,
                    4549951, 4550945, 4556799, 4560960, 4567512,
                    4565483, 4559004, 4565351, 4566116, 4574727,
                    4577062
                });

                break;

            default:
                return;
            }

            if (!supersedence.Intersect(installedKBs).Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #25
0
        public static void Check(VulnerabilityCollection vulnerabilities, SystemInfo sysInfo)
        {
            try
            {
                int version = SystemInfoHelpers.GetFileVersionInfoProductPrivatePart(sysInfo.WinPath + "\\win32k.sys");
                switch (sysInfo.OsBuild)
                {
                case "6001":
                    if (version < 18523)
                    {
                        vulnerabilities.SetAsVulnerable("MS10-073");
                    }
                    break;

                case "6002":
                    if (version < 18305)
                    {
                        vulnerabilities.SetAsVulnerable("MS10-073");
                    }
                    if (version < 18739)
                    {
                        vulnerabilities.SetAsVulnerable("MS13-005");
                    }
                    if (version < 18974)
                    {
                        vulnerabilities.SetAsVulnerable("MS13-101");
                    }
                    if (version < 19372)
                    {
                        vulnerabilities.SetAsVulnerable("MS15-051");
                    }
                    if (version < 19597)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-034");
                    }
                    break;

                case "7600":
                    if (version < 16667)
                    {
                        vulnerabilities.SetAsVulnerable("MS10-073");
                    }
                    if (version < 17017)
                    {
                        vulnerabilities.SetAsVulnerable("MS12-042");
                    }
                    if (version < 17175)
                    {
                        vulnerabilities.SetAsVulnerable("MS13-005");
                    }
                    break;

                case "9200":
                    if (version < 16468)
                    {
                        vulnerabilities.SetAsVulnerable("MS13-005");
                    }
                    if (version < 16758)
                    {
                        vulnerabilities.SetAsVulnerable("MS13-101");
                    }
                    if (version < 17130)
                    {
                        vulnerabilities.SetAsVulnerable("MS14-058");
                    }
                    if (version < 17343)
                    {
                        vulnerabilities.SetAsVulnerable("MS15-051");
                    }
                    break;

                case "9600":
                    if (version < 16457)
                    {
                        vulnerabilities.SetAsVulnerable("MS13-101");
                    }
                    if (version < 17796)
                    {
                        vulnerabilities.SetAsVulnerable("MS15-051");
                    }
                    if (version < 17353)
                    {
                        vulnerabilities.SetAsVulnerable("MS14-058");
                    }
                    if (version < 18228)
                    {
                        vulnerabilities.SetAsVulnerable("MS16-034");
                    }
                    break;
                }
            }
            catch (Exception ex)
            {
                vulnerabilities.AddError(ex.Message);
            }
        }
Пример #26
0
        public static void Check(VulnerabilityCollection vulnerabilities, int buildNumber, List <int> installedKBs)
        {
            var supersedence = new List <int>();

            switch (buildNumber)
            {
            case 10240:

                supersedence.AddRange(new int[] {
                    4493475, 4498375, 4499154, 4505051, 4503291,
                    4507458, 4512497, 4517276, 4522009, 4520011,
                    4524153, 4525232, 4530681, 4534306, 4537776,
                    4540693, 4550930, 4556826, 4561649, 4567518,
                    4565513, 4571692, 4577049
                });

                break;

            case 14393:

                supersedence.AddRange(new int[] {
                    4493470, 4499418, 4494440, 4534271, 4534307,
                    4537764, 4537806, 4540670, 4541329, 4550929,
                    4550947, 4556813, 4561616, 4567517, 4565511,
                    4571694, 4577015
                });

                break;

            case 15063:

                supersedence.AddRange(new int[] {
                    4493474, 4493436, 4499162, 4499181, 4502112,
                    4505055, 4503279, 4503289, 4509476, 4507450,
                    4507467, 4512474, 4512507, 4516059, 4516068,
                    4522011, 4520010, 4524151, 4525245, 4530711,
                    4534296, 4537765, 4540705, 4550939, 4556804,
                    4561605, 4567516, 4565499, 4571689, 4577021
                });

                break;

            case 16299:

                supersedence.AddRange(new int[] {
                    4493441, 4493440, 4499147, 4499179, 4505062,
                    4503281, 4503284, 4509477, 4507455, 4507465,
                    4512494, 4512516, 4516066, 4522012, 4520004,
                    4520006, 4524150, 4525241, 4530714, 4534276,
                    4534318, 4537789, 4537816, 4540681, 4541330,
                    4554342, 4550927, 4556812, 4561602, 4567515,
                    4565508, 4571741, 4577041
                });

                break;

            case 17134:

                supersedence.AddRange(new int[] {
                    4493464, 4493437, 4499167, 4499183, 4505064,
                    4503286, 4503288, 4509478, 4507435, 4507466,
                    4512501, 4512509, 4516045, 4516058, 4522014,
                    4519978, 4520008, 4524149, 4525237, 4530717,
                    4534293, 4534308, 4537762, 4537795, 4540689,
                    4541333, 4554349, 4550922, 4550944, 4556807,
                    4561621, 4567514, 4565489, 4571709, 4577032
                });

                break;

            case 17763:

                supersedence.AddRange(new int[] {
                    4493509, 4495667, 4494441, 4497934, 4501835,
                    4505056, 4501371, 4503327, 4509479, 4505658,
                    4507469, 4511553, 4512534, 4512578, 4522015,
                    4519338, 4520062, 4524148, 4523205, 4530715,
                    4534273, 4534321, 4532691, 4537818, 4538461,
                    4541331, 4554354, 4549949, 4550969, 4551853,
                    4561608, 4567513, 4558998, 4559003, 4565349,
                    4571748, 4570333, 4577069
                });

                break;

            default:
                return;
            }

            if (supersedence.Intersect(installedKBs).Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }
Пример #27
0
        public static void Check(VulnerabilityCollection vulnerabilities, string BuildNumber, List <string> installedKBs)
        {
            List <string> Supersedence = new List <string>();

            switch (BuildNumber)
            {
            case "10240":

                Supersedence.AddRange(new string[] {
                    "4520011"
                });

                break;

            case "10586":

                Supersedence.AddRange(new string[] {
                    //
                });

                break;

            case "14393":

                Supersedence.AddRange(new string[] {
                    "4519998"
                });

                break;

            case "15063":

                Supersedence.AddRange(new string[] {
                    "4520010"
                });

                break;

            case "16299":

                Supersedence.AddRange(new string[] {
                    "4520004"
                });

                break;

            case "17134":

                Supersedence.AddRange(new string[] {
                    "4520008"
                });

                break;

            case "17763":

                Supersedence.AddRange(new string[] {
                    "4519338"
                });

                break;

            case "18362":

                Supersedence.AddRange(new string[] {
                    "4517389"
                });

                break;

            default:
                return;
            }

            IEnumerable <string> x = Supersedence.Intersect(installedKBs);

            if (!x.Any())
            {
                vulnerabilities.SetAsVulnerable(name);
            }
        }