Ejemplo n.º 1
0
 protected override int?AnalyzeDataNew(HealthcheckData healthcheckData, ICollection <DomainKey> AllowedMigrationDomains)
 {
     foreach (HealthCheckTrustData trust in healthcheckData.Trusts)
     {
         bool skip = false;
         if (AllowedMigrationDomains != null)
         {
             foreach (DomainKey allowedDomain in AllowedMigrationDomains)
             {
                 if (allowedDomain == trust.Domain)
                 {
                     skip = true;
                     break;
                 }
                 if (trust.KnownDomains != null)
                 {
                     foreach (HealthCheckTrustDomainInfoData kd in trust.KnownDomains)
                     {
                         if (kd.Domain == allowedDomain)
                         {
                             skip = true;
                             break;
                         }
                     }
                 }
                 if (skip)
                 {
                     break;
                 }
             }
         }
         if (!skip && TrustAnalyzer.GetTGTDelegation(trust) == "Yes")
         {
             AddRawDetail(trust.TrustPartner);
         }
     }
     return(null);
 }
Ejemplo n.º 2
0
        private void GenerateTrustInformation()
        {
            List <string> knowndomains = new List <string>();

            GenerateSubSection("Discovered domains");
            AddBeginTable();
            AddHeaderText("Domain");
            AddHeaderText("Trust Partner");
            AddHeaderText("Type");
            AddHeaderText("Attribut");
            AddHeaderText("Direction");
            AddHeaderText("SID Filtering active");
            AddHeaderText("TGT Delegation");
            AddHeaderText("Creation");
            AddHeaderText("Is Active ?");
            AddBeginTableData();
            foreach (HealthcheckData data in Report)
            {
                if (!knowndomains.Contains(data.DomainFQDN))
                {
                    knowndomains.Add(data.DomainFQDN);
                }
                data.Trusts.Sort(
                    (HealthCheckTrustData a, HealthCheckTrustData b)
                    =>
                {
                    return(String.Compare(a.TrustPartner, b.TrustPartner));
                }
                    );

                foreach (HealthCheckTrustData trust in data.Trusts)
                {
                    if (!knowndomains.Contains(trust.TrustPartner))
                    {
                        knowndomains.Add(trust.TrustPartner);
                    }
                    AddBeginRow();
                    AddPrintDomain(data.Domain);
                    AddPrintDomain(trust.Domain);
                    AddCellText(TrustAnalyzer.GetTrustType(trust.TrustType));
                    AddCellText(TrustAnalyzer.GetTrustAttribute(trust.TrustAttributes));
                    AddCellText(TrustAnalyzer.GetTrustDirection(trust.TrustDirection));
                    AddCellText(TrustAnalyzer.GetSIDFiltering(trust));
                    AddCellText(TrustAnalyzer.GetTGTDelegation(trust));
                    AddCellDate(trust.CreationDate);
                    AddCellText(trust.IsActive.ToString());
                    AddEndRow();
                }
            }
            AddEndTable();
            GenerateSubSection("Other discovered domains");
            AddBeginTable();
            AddHeaderText("From");
            AddHeaderText("Reachable domain");
            AddHeaderText("Discovered using");
            AddHeaderText("Netbios");
            AddHeaderText("Creation date");
            AddBeginTableData();
            foreach (HealthcheckData data in Report)
            {
                foreach (HealthCheckTrustData trust in data.Trusts)
                {
                    if (trust.KnownDomains == null)
                    {
                        continue;
                    }
                    trust.KnownDomains.Sort((HealthCheckTrustDomainInfoData a, HealthCheckTrustDomainInfoData b)
                                            =>
                    {
                        return(String.Compare(a.DnsName, b.DnsName));
                    }
                                            );
                    foreach (HealthCheckTrustDomainInfoData di in trust.KnownDomains)
                    {
                        if (knowndomains.Contains(di.DnsName))
                        {
                            continue;
                        }
                        knowndomains.Add(di.DnsName);
                        AddBeginRow();
                        AddPrintDomain(data.Domain);
                        AddCellText(di.DnsName);
                        AddCellText(trust.TrustPartner);
                        AddCellText(di.NetbiosName);
                        AddCellDate(di.CreationDate);
                        AddEndRow();
                    }
                }
            }
            foreach (HealthcheckData data in Report)
            {
                if (data.ReachableDomains != null)
                {
                    foreach (HealthCheckTrustDomainInfoData di in data.ReachableDomains)
                    {
                        if (knowndomains.Contains(di.DnsName))
                        {
                            continue;
                        }
                        knowndomains.Add(di.DnsName);
                        AddBeginRow();
                        AddPrintDomain(data.Domain);
                        AddCellText(di.DnsName);
                        AddCellText("Unknown");
                        AddCellText(di.NetbiosName);
                        AddCellText("Unknown");
                        AddEndRow();
                    }
                }
            }

            AddEndTable();

            // prepare a SID map to locate unknown account
            SortedDictionary <string, string> sidmap = new SortedDictionary <string, string>();

            GenerateSubSection("SID Map");
            AddBeginTable();
            AddHeaderText("Domain");
            AddHeaderText("Domain SID");
            AddBeginTableData();
            foreach (HealthcheckData data in Report)
            {
                if (!sidmap.ContainsKey(data.DomainFQDN) && !String.IsNullOrEmpty(data.DomainSid))
                {
                    sidmap.Add(data.DomainFQDN, data.DomainSid);
                }
                foreach (HealthCheckTrustData trust in data.Trusts)
                {
                    if (!sidmap.ContainsKey(trust.TrustPartner) && !String.IsNullOrEmpty(trust.SID))
                    {
                        sidmap.Add(trust.TrustPartner, trust.SID);
                    }
                    foreach (HealthCheckTrustDomainInfoData di in trust.KnownDomains)
                    {
                        if (!sidmap.ContainsKey(di.DnsName) && !String.IsNullOrEmpty(di.Sid))
                        {
                            sidmap.Add(di.DnsName, di.Sid);
                        }
                    }
                }
            }
            foreach (HealthcheckData data in Report)
            {
                if (data.ReachableDomains != null)
                {
                    foreach (HealthCheckTrustDomainInfoData di in data.ReachableDomains)
                    {
                        if (!sidmap.ContainsKey(di.DnsName) && !String.IsNullOrEmpty(di.Sid))
                        {
                            sidmap.Add(di.DnsName, di.Sid);
                        }
                    }
                }
            }
            foreach (string domain in sidmap.Keys)
            {
                AddBeginRow();
                AddCellText(domain);
                AddCellText(sidmap[domain]);
                AddEndRow();
            }
            AddEndTable();
        }
Ejemplo n.º 3
0
        private void GenerateTrustInformation()
        {
            List <string> knowndomains = new List <string>();

            GenerateSubSection("Discovered domains");
            Add(@"
		<div class=""row"">
			<div class=""col-md-12 table-responsive"">
				<table class=""table table-striped table-bordered"">
					<thead><tr>
						<th>Domain</th>
						<th>Trust Partner</th>
						<th>Type</th>
						<th>Attribut</th>
						<th>Direction</th>
						<th>SID Filtering active</th>
						<th>TGT Delegation</th>
						<th>Creation</th>
						<th>Is Active ?</th>
						</tr>
					</thead>
					<tbody>
");
            foreach (HealthcheckData data in Report)
            {
                if (!knowndomains.Contains(data.DomainFQDN))
                {
                    knowndomains.Add(data.DomainFQDN);
                }
                data.Trusts.Sort(
                    (HealthCheckTrustData a, HealthCheckTrustData b)
                    =>
                {
                    return(String.Compare(a.TrustPartner, b.TrustPartner));
                }
                    );

                foreach (HealthCheckTrustData trust in data.Trusts)
                {
                    if (!knowndomains.Contains(trust.TrustPartner))
                    {
                        knowndomains.Add(trust.TrustPartner);
                    }
                    Add(@"
						<tr>
							<td class='text'>"                             + PrintDomain(data.Domain) + @"</td>
							<td class='text'>"                             + PrintDomain(trust.Domain) + @"</td>
							<td class='text'>"                             + TrustAnalyzer.GetTrustType(trust.TrustType) + @"</td>
							<td class='text'>"                             + TrustAnalyzer.GetTrustAttribute(trust.TrustAttributes) + @"</td>
							<td class='text'>"                             + TrustAnalyzer.GetTrustDirection(trust.TrustDirection) + @"</td>
							<td class='text'>"                             + TrustAnalyzer.GetSIDFiltering(trust) + @"</td>
							<td class='text'>"                             + TrustAnalyzer.GetTGTDelegation(trust) + @"</td>
							<td class='text'>"                             + trust.CreationDate.ToString("u") + @"</td>
							<td class='text'>"                             + trust.IsActive + @"</td>
						</tr>
");
                }
            }
            Add(@"
					</tbody>
				</table>
			</div>
		</div>
");
            GenerateSubSection("Other discovered domains");
            Add(@"
		<div class=""row"">
			<div class=""col-md-12 table-responsive"">
				<table class=""table table-striped table-bordered"">
					<thead><tr> 
						<th>From</th>
						<th>Reachable domain</th>
						<th>Via</th>
						<th>Netbios</th>
						<th>Creation date</th>
						</tr>
					</thead>
					<tbody>
");
            foreach (HealthcheckData data in Report)
            {
                foreach (HealthCheckTrustData trust in data.Trusts)
                {
                    if (trust.KnownDomains == null)
                    {
                        continue;
                    }
                    trust.KnownDomains.Sort((HealthCheckTrustDomainInfoData a, HealthCheckTrustDomainInfoData b)
                                            =>
                    {
                        return(String.Compare(a.DnsName, b.DnsName));
                    }
                                            );
                    foreach (HealthCheckTrustDomainInfoData di in trust.KnownDomains)
                    {
                        if (knowndomains.Contains(di.DnsName))
                        {
                            continue;
                        }
                        knowndomains.Add(di.DnsName);
                        Add(@"
						<tr>
							<td class='text'>"                            );
                        Add(PrintDomain(data.Domain));
                        Add(@"</td>
							<td class='text'>"                            );
                        AddEncoded(di.DnsName);
                        Add(@"</td>
							<td class='text'>"                            );
                        AddEncoded(trust.TrustPartner);
                        Add(@"</td>
							<td class='text'>"                            );
                        AddEncoded(di.NetbiosName);
                        Add(@"</td>
							<td class='text'>"                            );
                        Add(di.CreationDate);
                        Add(@"</td>
						</tr>
");
                    }
                }
            }
            foreach (HealthcheckData data in Report)
            {
                if (data.ReachableDomains != null)
                {
                    foreach (HealthCheckTrustDomainInfoData di in data.ReachableDomains)
                    {
                        if (knowndomains.Contains(di.DnsName))
                        {
                            continue;
                        }
                        knowndomains.Add(di.DnsName);
                        Add(@"
						<tr>
							<td class='text'>"                            );
                        Add(PrintDomain(data.Domain));
                        Add(@"</td>
							<td class='text'>"                            );
                        AddEncoded(di.DnsName);
                        Add(@"</td>
							<td class='text'>Unknown</td>
							<td class='text'>"                            );
                        AddEncoded(di.NetbiosName);
                        Add(@"</td>
							<td class='text'>Unknown</td>
						</tr>
");
                    }
                }
            }

            Add(@"
					</tbody>
				</table>
			</div>
		</div>
");

            // prepare a SID map to locate unknown account
            SortedDictionary <string, string> sidmap = new SortedDictionary <string, string>();

            GenerateSubSection("SID Map");
            Add(@"
		<div class=""row"">
			<div class=""col-md-12 table-responsive"">
				<table class=""table table-striped table-bordered"">
					<thead><tr>
						<th>Domain</th>
						<th>Domain SID</th>
						</tr>
					</thead>
					<tbody>
");
            foreach (HealthcheckData data in Report)
            {
                if (!sidmap.ContainsKey(data.DomainFQDN) && !String.IsNullOrEmpty(data.DomainSid))
                {
                    sidmap.Add(data.DomainFQDN, data.DomainSid);
                }
                foreach (HealthCheckTrustData trust in data.Trusts)
                {
                    if (!sidmap.ContainsKey(trust.TrustPartner) && !String.IsNullOrEmpty(trust.SID))
                    {
                        sidmap.Add(trust.TrustPartner, trust.SID);
                    }
                    foreach (HealthCheckTrustDomainInfoData di in trust.KnownDomains)
                    {
                        if (!sidmap.ContainsKey(di.DnsName) && !String.IsNullOrEmpty(di.Sid))
                        {
                            sidmap.Add(di.DnsName, di.Sid);
                        }
                    }
                }
            }
            foreach (HealthcheckData data in Report)
            {
                if (data.ReachableDomains != null)
                {
                    foreach (HealthCheckTrustDomainInfoData di in data.ReachableDomains)
                    {
                        if (!sidmap.ContainsKey(di.DnsName) && !String.IsNullOrEmpty(di.Sid))
                        {
                            sidmap.Add(di.DnsName, di.Sid);
                        }
                    }
                }
            }
            foreach (string domain in sidmap.Keys)
            {
                Add(@"
						<tr>
							<td class='text'>"                            );
                AddEncoded(domain);
                Add(@"</td>
							<td class='text'>"                            );
                Add(sidmap[domain]);
                Add(@"</td>
						</tr>
");
            }
            Add(@"
					</tbody>
				</table>
			</div>
		</div>
");
        }