Esempio n. 1
0
        public async static void SupplyChainDomainScan(string domainName)
        {
            string                 parsedDomain = GetDomain.GetDomainName(domainName);
            ParsedSPFRecord        spfParse     = await new SPFParse().GetSPF(parsedDomain, 1);
            SPFDMARCRecord         spfDmarc     = new SPFParse().GetSPFDMARCRecord(parsedDomain);
            List <IssueScanResult> issues       = new IssueEngine().IssueScan(spfDmarc, spfParse);

            ResultModel spoofResults = new ResultModel();

            spoofResults.issueScan = issues;

            spoofResults.parsedSPFRecordOutput = spfParse;
            spoofResults.domain = parsedDomain;
            if (spfParse != null)
            {
                spoofResults.mapLocation = new Geolocation().MapLocationRollUp(spfParse);
                if (spfDmarc.spfRecord.Contains("redirect="))
                {
                    string[] splitSPF = spfDmarc.spfRecord.Split(' ');
                    int      index    = Array.FindIndex(splitSPF, x => x.Contains("redirect="));
                    spoofResults.redirectedSPF = new SPFParse().GetSPFDMARCRecord(splitSPF[index].Split('=')[1]).spfRecord;
                }
            }
            spoofResults.dnsResult = spfDmarc;
            PrintSupplyChain(spoofResults);
        }
Esempio n. 2
0
        private static async void ScanAndSave(List <string> domainList, string outputFile)
        {
            List <SubDomainOutput> domainsAggregated = new List <SubDomainOutput>();
            int i = 1;

            foreach (string uniqueDomain in domainList)
            {
                Console.WriteLine("-------------------------");
                Console.WriteLine("Domain Count: {0}", i);
                i++;
                SubDomainOutput domainModel = new SubDomainOutput();
                domainModel.SubDomain = uniqueDomain;
                Console.WriteLine("Domain Name: {0}", uniqueDomain);
                SPFParse       getSPFDMARC = new SPFParse();
                SPFDMARCRecord spfDMARC    = getSPFDMARC.GetSPFDMARCRecord(domainModel.SubDomain);

                ParsedSPFRecord spfParse = await new SPFParseScheduler().GetSPF(domainModel.SubDomain, 1);

                List <IssueScanResult> issues = new IssueEngine().IssueScan(spfDMARC, spfParse);

                string issueSeverity = "";
                foreach (IssueScanResult issue in issues)
                {
                    if (issue.severity == "Very High")
                    {
                        issueSeverity = issue.severity;
                    }
                    if (issueSeverity != "Very High")
                    {
                        if (issue.severity == "High")
                        {
                            issueSeverity = issue.severity;
                        }
                        if (issueSeverity != "High")
                        {
                            if (issue.severity == "Medium")
                            {
                                issueSeverity = issue.severity;
                            }
                            if (issueSeverity != "Medium")
                            {
                                if (issue.severity == "Low")
                                {
                                    issueSeverity = issue.severity;
                                }
                                else if (issue.severity == "Mitigated")
                                {
                                    issueSeverity = "Secure";
                                }
                            }
                        }
                    }
                }
                domainModel.Spoofable = issueSeverity;
                if (spfDMARC.spfRecord == null)
                {
                    domainModel.SPFRecord = "";
                }
                else
                {
                    domainModel.SPFRecord = spfDMARC.spfRecord;
                }
                if (spfDMARC.dmarcRecord == null)
                {
                    domainModel.DMARCRecord = "";
                }
                else
                {
                    if (spfDMARC.dmarcRecord.Contains("; p=none") || spfDMARC.dmarcRecord.Contains(";p=none"))
                    {
                        domainModel.DMARCRecord = "Audit";
                    }
                    else if (spfDMARC.dmarcRecord.Contains("; p=quarantine") || spfDMARC.dmarcRecord.Contains(";p=quarantine"))
                    {
                        domainModel.DMARCRecord = "Quarantine";
                    }
                    else if (spfDMARC.dmarcRecord.Contains("; p=reject") || spfDMARC.dmarcRecord.Contains(";p=reject"))
                    {
                        domainModel.DMARCRecord = "Reject";
                    }
                    else
                    {
                        domainModel.DMARCRecord = "-";
                    }
                }
                domainModel.searchEngine = "N/A";
                domainsAggregated.Add(domainModel);

                Console.WriteLine("Spoof Rating: {0}", domainModel.Spoofable);
                Console.WriteLine("SPF Record: {0}", domainModel.SPFRecord);
                Console.WriteLine("DMARC Record: {0}", domainModel.DMARCRecord);
            }

            // serialize JSON directly to a file
            using (StreamWriter file = File.CreateText(outputFile))
            {
                JsonSerializer serializer = new JsonSerializer();
                serializer.Serialize(file, domainsAggregated);
            }
            Console.WriteLine("");
            Console.WriteLine("All domains have been scanned. The results are viewable at: {0}", outputFile);
        }